private List<TypeMirror> createAllowedChildFrameTypes(NodeData parentNode) { List<TypeMirror> allowedFrameTypes = new ArrayList<>(); for (TypeMirror frameType : context.getFrameTypes()) { if (ElementUtils.isAssignable(parentNode.getFrameType(), frameType)) { allowedFrameTypes.add(frameType); } } return allowedFrameTypes; }
private List<TypeMirror> createAllowedChildFrameTypes(NodeData parentNode) { List<TypeMirror> allowedFrameTypes = new ArrayList<>(); for (TypeMirror frameType : context.getFrameTypes()) { if (ElementUtils.isAssignable(parentNode.getFrameType(), frameType)) { allowedFrameTypes.add(frameType); } } return allowedFrameTypes; }
private boolean isNodeInterfaceArray(TypeMirror type) { if (type == null) { return false; } return type.getKind() == TypeKind.ARRAY && ElementUtils.isAssignable(((ArrayType) type).getComponentType(), context.getType(NodeInterface.class)); }
private ExecutableElement findGetter(List<? extends Element> elements, String variableName, TypeMirror type) { if (type == null) { return null; } String methodName; if (ElementUtils.typeEquals(type, context.getType(boolean.class))) { methodName = "is" + ElementUtils.firstLetterUpperCase(variableName); } else { methodName = "get" + ElementUtils.firstLetterUpperCase(variableName); } for (ExecutableElement method : ElementFilter.methodsIn(elements)) { if (method.getSimpleName().toString().equals(methodName) && method.getParameters().size() == 0 && ElementUtils.isAssignable(type, method.getReturnType())) { return method; } } return null; }
private ExecutableElement findGetter(List<? extends Element> elements, String variableName, TypeMirror type) { if (type == null) { return null; } String methodName; if (ElementUtils.typeEquals(type, context.getType(boolean.class))) { methodName = "is" + ElementUtils.firstLetterUpperCase(variableName); } else { methodName = "get" + ElementUtils.firstLetterUpperCase(variableName); } for (ExecutableElement method : ElementFilter.methodsIn(elements)) { if (method.getSimpleName().toString().equals(methodName) && method.getParameters().size() == 0 && ElementUtils.isAssignable(type, method.getReturnType())) { return method; } } return null; }
public static boolean needsCastTo(TypeMirror sourceType, TypeMirror targetType) { if (typeEquals(sourceType, targetType)) { return false; } else if (isObject(targetType)) { return false; } else if (isVoid(targetType)) { return false; } else if (isAssignable(sourceType, targetType)) { return false; } return true; }
public static boolean needsCastTo(TypeMirror sourceType, TypeMirror targetType) { if (typeEquals(sourceType, targetType)) { return false; } else if (isObject(targetType)) { return false; } else if (isVoid(targetType)) { return false; } else if (isAssignable(sourceType, targetType)) { return false; } return true; }
private static Map<Variable, CodeTree> castBoundTypes(Map<Variable, LocalVariable> bindings) { Map<Variable, CodeTree> resolvedBindings = new HashMap<>(); for (Variable variable : bindings.keySet()) { LocalVariable localVariable = bindings.get(variable); CodeTree resolved = localVariable.createReference(); TypeMirror sourceType = localVariable.getTypeMirror(); TypeMirror targetType = variable.getResolvedTargetType(); if (targetType == null) { targetType = variable.getResolvedType(); } if (!ElementUtils.isAssignable(sourceType, targetType)) { resolved = CodeTreeBuilder.createBuilder().cast(targetType, resolved).build(); } resolvedBindings.put(variable, resolved); } return resolvedBindings; }
boolean supportedType = false; for (TypeMirror type : frameTypes) { if (ElementUtils.isAssignable(type, executableType.getFrameParameter())) { supportedType = true; break;
boolean supportedType = false; for (TypeMirror type : frameTypes) { if (ElementUtils.isAssignable(type, executableType.getFrameParameter())) { supportedType = true; break;
private static Map<Variable, CodeTree> castBoundTypes(Map<Variable, LocalVariable> bindings) { Map<Variable, CodeTree> resolvedBindings = new HashMap<>(); for (Variable variable : bindings.keySet()) { LocalVariable localVariable = bindings.get(variable); CodeTree resolved = localVariable.createReference(); TypeMirror sourceType = localVariable.getTypeMirror(); TypeMirror targetType = variable.getResolvedTargetType(); if (targetType == null) { targetType = variable.getResolvedType(); } if (!ElementUtils.isAssignable(sourceType, targetType)) { resolved = CodeTreeBuilder.createBuilder().startParantheses().cast(targetType, resolved).end().build(); } resolvedBindings.put(variable, resolved); } return resolvedBindings; }
TypeMirror sourceType = expression.getResolvedType(); TypeMirror targetType = parameters.get(parameterIndex).asType(); if (!ElementUtils.isAssignable(sourceType, targetType)) { continue outer;
private NodeData parseChildNodeData(NodeData parentNode, NodeChildData child, TypeElement originalTemplateType) { TypeElement templateType = ElementUtils.fromTypeMirror(context.reloadTypeElement(originalTemplateType)); if (ElementUtils.findAnnotationMirror(processingEnv, originalTemplateType, GeneratedBy.class) != null) { // generated nodes should not get called again. return null; } if (!ElementUtils.isAssignable(templateType.asType(), context.getTruffleTypes().getNode())) { return null; } List<TypeElement> lookupTypes = collectSuperClasses(new ArrayList<TypeElement>(), templateType); // Declaration order is not required for child nodes. List<? extends Element> members = processingEnv.getElementUtils().getAllMembers(templateType); NodeData node = parseNodeData(templateType, lookupTypes); if (node.hasErrors()) { return node; } List<TypeMirror> frameTypes = Collections.emptyList(); if (parentNode.getFrameType() != null) { frameTypes = Arrays.asList(parentNode.getFrameType()); } node.getExecutableTypes().addAll(parseExecutableTypeData(node, members, child.getExecuteWith().size(), frameTypes, true)); node.setFrameType(parentNode.getFrameType()); return node; }
private NodeData parseChildNodeData(NodeData parentNode, NodeChildData child, TypeElement originalTemplateType) { TypeElement templateType = ElementUtils.fromTypeMirror(context.reloadTypeElement(originalTemplateType)); if (ElementUtils.findAnnotationMirror(processingEnv, originalTemplateType, GeneratedBy.class) != null) { // generated nodes should not get called again. return null; } if (!ElementUtils.isAssignable(templateType.asType(), context.getTruffleTypes().getNode())) { return null; } List<TypeElement> lookupTypes = collectSuperClasses(new ArrayList<TypeElement>(), templateType); // Declaration order is not required for child nodes. List<? extends Element> members = processingEnv.getElementUtils().getAllMembers(templateType); NodeData node = parseNodeData(templateType, lookupTypes); if (node.hasErrors()) { return node; } List<TypeMirror> frameTypes = Collections.emptyList(); if (parentNode.getFrameType() != null) { frameTypes = Arrays.asList(parentNode.getFrameType()); } node.getExecutableTypes().addAll(parseExecutableTypeData(node, members, child.getExecuteWith().size(), frameTypes, true)); node.setFrameType(parentNode.getFrameType()); return node; }
private boolean specializationClassIsNode(SpecializationData specialization) { boolean useSpecializationClass = useSpecializationClass(specialization); if (useSpecializationClass) { for (CacheExpression cache : specialization.getCaches()) { TypeMirror type = cache.getParameter().getType(); if (ElementUtils.isAssignable(type, context.getType(NodeInterface.class))) { return true; } else if (isNodeInterfaceArray(type)) { return true; } } } return false; }
private List<ExecutableTypeData> filterCompatibleExecutableTypes(ExecutableTypeData type, List<ExecutableTypeData> genericExecutes) { List<ExecutableTypeData> compatible = new ArrayList<>(); outer: for (ExecutableTypeData genericExecute : genericExecutes) { if (genericExecute.getEvaluatedCount() != type.getEvaluatedCount()) { continue; } for (int i = 0; i < genericExecute.getEvaluatedCount(); i++) { TypeMirror sourceType = type.getSignatureParameters().get(i); TypeMirror targetType = genericExecute.getSignatureParameters().get(i); if (!ElementUtils.isAssignable(sourceType, targetType)) { continue outer; } } if (!isVoid(type.getReturnType()) && !isSubtypeBoxed(context, type.getReturnType(), genericExecute.getReturnType()) && !isSubtypeBoxed(context, genericExecute.getReturnType(), type.getReturnType())) { continue outer; } compatible.add(genericExecute); } return compatible; }
private CodeTree createCatchRewriteException(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData forType, FrameState frameState, CodeTree execution, NodeExecutionMode mode) { if (specialization.getExceptions().isEmpty()) { return execution; } CodeTreeBuilder builder = parent.create(); builder.startTryBlock(); builder.tree(execution); boolean nonSlowPath = false; TypeMirror[] exceptionTypes = new TypeMirror[specialization.getExceptions().size()]; for (int i = 0; i < exceptionTypes.length; i++) { TypeMirror type = specialization.getExceptions().get(i).getJavaClass(); if (!ElementUtils.isAssignable(type, context.getType(SlowPathException.class)) && !ElementUtils.isAssignable(type, context.getType(ArithmeticException.class))) { nonSlowPath = true; } exceptionTypes[i] = type; } builder.end().startCatchBlock(exceptionTypes, "ex"); if (nonSlowPath) { builder.tree(createTransferToInterpreterAndInvalidate()); } else { builder.lineComment("implicit transferToInterpreterAndInvalidate()"); } builder.tree(createExcludeThis(builder, frameState, forType, specialization, mode)); builder.end(); return builder.build(); }
private void initializeAssumptions(SpecializationData specialization, DSLExpressionResolver resolver) { final DeclaredType assumptionType = context.getDeclaredType(Assumption.class); final TypeMirror assumptionArrayType = new ArrayCodeTypeMirror(assumptionType); final List<String> assumptionDefinitions = ElementUtils.getAnnotationValueList(String.class, specialization.getMarkerAnnotation(), "assumptions"); List<AssumptionExpression> assumptionExpressions = new ArrayList<>(); int assumptionId = 0; for (String assumption : assumptionDefinitions) { AssumptionExpression assumptionExpression; DSLExpression expression = null; try { expression = DSLExpression.parse(assumption); expression.accept(resolver); assumptionExpression = new AssumptionExpression(specialization, expression, "assumption" + assumptionId); if (!ElementUtils.isAssignable(expression.getResolvedType(), assumptionType) && !ElementUtils.isAssignable(expression.getResolvedType(), assumptionArrayType)) { assumptionExpression.addError("Incompatible return type %s. Assumptions must be assignable to %s or %s.", ElementUtils.getSimpleName(expression.getResolvedType()), ElementUtils.getSimpleName(assumptionType), ElementUtils.getSimpleName(assumptionArrayType)); } if (specialization.isDynamicParameterBound(expression)) { specialization.addError("Assumption expressions must not bind dynamic parameter values."); } } catch (InvalidExpressionException e) { assumptionExpression = new AssumptionExpression(specialization, null, "assumption" + assumptionId); assumptionExpression.addError("Error parsing expression '%s': %s", assumption, e.getMessage()); } assumptionExpressions.add(assumptionExpression); } specialization.setAssumptionExpressions(assumptionExpressions); }
private void initializeAssumptions(SpecializationData specialization, DSLExpressionResolver resolver) { final DeclaredType assumptionType = context.getDeclaredType(Assumption.class); final TypeMirror assumptionArrayType = new ArrayCodeTypeMirror(assumptionType); final List<String> assumptionDefinitions = ElementUtils.getAnnotationValueList(String.class, specialization.getMarkerAnnotation(), "assumptions"); List<AssumptionExpression> assumptionExpressions = new ArrayList<>(); int assumptionId = 0; for (String assumption : assumptionDefinitions) { AssumptionExpression assumptionExpression; DSLExpression expression = null; try { expression = DSLExpression.parse(assumption); expression.accept(resolver); assumptionExpression = new AssumptionExpression(specialization, expression, "assumption" + assumptionId); if (!ElementUtils.isAssignable(expression.getResolvedType(), assumptionType) && !ElementUtils.isAssignable(expression.getResolvedType(), assumptionArrayType)) { assumptionExpression.addError("Incompatible return type %s. Assumptions must be assignable to %s or %s.", ElementUtils.getSimpleName(expression.getResolvedType()), ElementUtils.getSimpleName(assumptionType), ElementUtils.getSimpleName(assumptionArrayType)); } if (specialization.isDynamicParameterBound(expression)) { specialization.addError("Assumption expressions must not bind dynamic parameter values."); } } catch (InvalidExpressionException e) { assumptionExpression = new AssumptionExpression(specialization, null, "assumption" + assumptionId); assumptionExpression.addError("Error parsing expression '%s': %s", assumption, e.getMessage()); } assumptionExpressions.add(assumptionExpression); assumptionId++; } specialization.setAssumptionExpressions(assumptionExpressions); }
if (!ElementUtils.isAssignable(templateType.asType(), context.getTruffleTypes().getNode())) { return null;