private CodeExecutableElement createIsTypeMethod(TypeMirror type) { if (typeSystem.getCheck(type) != null) { return null; } CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(boolean.class), TypeSystemCodeGenerator.isTypeMethodName(typeSystem, type)); method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); CodeTreeBuilder body = method.createBuilder(); body.startReturn().tree(check(typeSystem, type, LOCAL_VALUE)).end(); return method; }
public static CodeExecutableElement clone(@SuppressWarnings("unused") ProcessingEnvironment env, ExecutableElement method) { CodeExecutableElement copy = new CodeExecutableElement(method.getReturnType(), method.getSimpleName().toString()); for (TypeMirror thrownType : method.getThrownTypes()) { copy.addThrownType(thrownType); } copy.setDefaultValue(method.getDefaultValue()); for (AnnotationMirror mirror : method.getAnnotationMirrors()) { copy.addAnnotationMirror(mirror); } for (VariableElement var : method.getParameters()) { copy.addParameter(CodeVariableElement.clone(var)); } for (Element element : method.getEnclosedElements()) { copy.add(element); } copy.getModifiers().addAll(method.getModifiers()); copy.setVarArgs(method.isVarArgs()); return copy; }
private Element createSpecializationCreateMethod(SpecializationData specialization, CodeExecutableElement constructor) { if (!useLazyClassLoading()) { return null; } CodeExecutableElement executable = CodeExecutableElement.clone(context.getEnvironment(), constructor); executable.setReturnType(specializationType(null)); executable.setSimpleName(CodeNames.of("create")); executable.getModifiers().add(STATIC); CodeTreeBuilder builder = executable.createBuilder(); builder.startReturn().startNew(specializationType(specialization)); for (VariableElement parameter : executable.getParameters()) { builder.string(parameter.getSimpleName().toString()); } builder.end().end(); return executable; }
@Override public Void visitExecutable(CodeExecutableElement e, Void p) { visitAnnotations(e, e.getAnnotationMirrors()); if (e.getReturnType() != null) { visitTypeReference(e, e.getReturnType()); } for (TypeMirror type : e.getThrownTypes()) { visitTypeReference(e, type); } return super.visitExecutable(e, p); }
@Override public Void visitExecutable(CodeExecutableElement e, Void p) { if (!e.getModifiers().contains(Modifier.STATIC) && !e.getModifiers().contains(Modifier.PRIVATE)) { String name = e.getSimpleName().toString(); TypeMirror[] params = e.getParameterTypes(); for (AnnotationMirror mirror : e.getAnnotationMirrors()) { if (ElementUtils.typeEquals(overrideType, mirror.getAnnotationType())) { // already declared (may happen if method copied from super class) return super.visitExecutable(e, p); } } if (isDeclaredMethodInSuperType(e.getEnclosingClass(), name, params)) { e.addAnnotationMirror(new CodeAnnotationMirror(overrideType)); } } return super.visitExecutable(e, p); }
@Override public Void visitExecutable(CodeExecutableElement e, Void p) { for (AnnotationMirror annotation : e.getAnnotationMirrors()) { visitAnnotation(e, annotation); writeLn(); writeModifiers(e.getModifiers(), !e.getEnclosingClass().getModifiers().contains(Modifier.FINAL)); if (e.getReturnType() != null) { write(useImport(e, e.getReturnType())); write(" "); write(e.getSimpleName()); write("("); for (int i = 0; i < e.getParameters().size(); i++) { VariableElement param = e.getParameters().get(i); param.accept(this, p); if (i < e.getParameters().size() - 1) { write(", "); List<TypeMirror> throwables = e.getThrownTypes(); if (throwables.size() > 0) { write(" throws "); if (e.getModifiers().contains(Modifier.ABSTRACT)) { writeLn(";"); } else if (e.getBodyTree() != null) { writeLn(" {"); indent(1);
constructors.add(new CodeExecutableElement(ElementUtils.modifiers(Modifier.PUBLIC), null, e.getSimpleName().toString())); CodeExecutableElement getter = new CodeExecutableElement(ElementUtils.modifiers(Modifier.PUBLIC), field.asType(), "get" + ElementUtils.firstLetterUpperCase(field.getSimpleName().toString())); getter.createBuilder().startReturn().string(field.getSimpleName().toString()).end(); wrapperType.add(getter); CodeExecutableElement getInstrumentationTags = new CodeExecutableElement(ElementUtils.modifiers(Modifier.PUBLIC), returnType, METHOD_GET_NODE_COST); getInstrumentationTags.createBuilder().startReturn().staticReference(returnType, "NONE").end(); wrapperType.add(getInstrumentationTags); CodeExecutableElement wrappedExecute = CodeExecutableElement.clone(processingEnv, executeMethod); wrappedExecute.getModifiers().remove(Modifier.ABSTRACT); wrappedExecute.getAnnotationMirrors().clear(); for (VariableElement parameter : wrappedExecute.getParameters()) { if (ElementUtils.typeEquals(context.getType(VirtualFrame.class), parameter.asType())) { frameParameterName = parameter.getSimpleName().toString(); CodeTreeBuilder builder = wrappedExecute.createBuilder(); TypeMirror returnTypeMirror = executeMethod.getReturnType(); boolean returnVoid = ElementUtils.isVoid(returnTypeMirror); for (VariableElement parameter : wrappedExecute.getParameters()) { callDelegate.string(parameter.getSimpleName().toString()); builder.startStatement().startCall(FIELD_PROBE, METHOD_ON_RETURN_VALUE).string(frameParameterName).string(returnName).end().end(); builder.statement("break"); if (wrappedExecute.getThrownTypes().contains(context.getType(UnexpectedResultException.class))) {
executable = CodeExecutableElement.clone(context.getEnvironment(), executedType.getMethod()); executable.getAnnotationMirrors().clear(); executable.getModifiers().remove(ABSTRACT); for (VariableElement var : executable.getParameters()) { ((CodeVariableElement) var).getAnnotationMirrors().clear(); ((CodeVariableElement) executable.getParameters().get(0)).setName(FRAME_VALUE); if (executable.isVarArgs()) { ((CodeVariableElement) executable.getParameters().get(executable.getParameters().size() - 1)).setName(VARARGS_NAME); executable = currentLocals.createMethod(modifiers(PUBLIC), returnType, methodName, varArgs, FRAME_VALUE); executable.getThrownTypes().clear(); executable.getThrownTypes().add(context.getDeclaredType(UnexpectedResultException.class));
private Element createCreatePolymorphic(Map<SpecializationData, CodeTypeElement> generatedSpecializationClasses) { SpecializationData polymorphic = node.getPolymorphicSpecialization(); CodeTypeElement generatedPolymorphic = generatedSpecializationClasses.get(polymorphic); if (generatedPolymorphic == null) { return null; } TypeMirror returnType = getType(SpecializationNode.class); CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), returnType, "createPolymorphic"); method.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(Override.class))); method.createBuilder().startReturn().tree(createCallCreateMethod(polymorphic, null, null)).end(); return method; }
public static CodeExecutableElement createExpectMethod(Modifier visibility, TypeSystemData typeSystem, TypeMirror sourceTypeOriginal, TypeMirror expectedTypeOriginal) { TypeMirror expectedType = ElementUtils.fillInGenericWildcards(expectedTypeOriginal); TypeMirror sourceType = ElementUtils.fillInGenericWildcards(sourceTypeOriginal); if (ElementUtils.isObject(expectedType) || ElementUtils.isVoid(expectedType)) { return null; } CodeExecutableElement method = new CodeExecutableElement(modifiers(STATIC), expectedType, TypeSystemCodeGenerator.expectTypeMethodName(typeSystem, expectedType)); method.setVisibility(visibility); method.addParameter(new CodeVariableElement(sourceType, LOCAL_VALUE)); method.addThrownType(typeSystem.getContext().getTruffleTypes().getUnexpectedValueException()); CodeTreeBuilder body = method.createBuilder(); body.startIf().tree(check(typeSystem, expectedType, LOCAL_VALUE)).end().startBlock(); body.startReturn().tree(cast(typeSystem, expectedType, LOCAL_VALUE)).end(); body.end(); body.startThrow().startNew(typeSystem.getContext().getTruffleTypes().getUnexpectedValueException()).string(LOCAL_VALUE).end().end(); return method; }
private Element createIsIdenticalMethod(SpecializationData specialization) { boolean cacheBoundGuard = specialization.hasMultipleInstances(); if (!cacheBoundGuard) { return null; } LocalContext currentLocals = LocalContext.load(this, createSpecializationNodeSignature(node.getSignatureSize()), varArgsThreshold); currentLocals.loadFastPathState(specialization); CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), getType(boolean.class), "isIdentical"); method.addParameter(new CodeVariableElement(getType(SpecializationNode.class), "other")); currentLocals.addParametersTo(method, varArgsThreshold, FRAME_VALUE); method.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(Override.class))); final CodeTreeBuilder builder = method.createBuilder(); SpecializationGroup group = SpecializationGroup.create(specialization); SpecializationBody executionFactory = new SpecializationBody(true, false) { @Override public CodeTree createBody(SpecializationData s, LocalContext values) { return builder.create().returnTrue().build(); } }; builder.tree(createGuardAndCast(group, genericType, currentLocals, executionFactory)); builder.returnFalse(); return method; }
private CodeExecutableElement createExpectImplicitTypeMethodFlat(TypeMirror type) { String name = expectImplicitTypeMethodName(typeSystem, type); CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), type, name); method.addParameter(new CodeVariableElement(context.getType(int.class), "state")); method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); method.getThrownTypes().add(context.getType(UnexpectedResultException.class)); List<TypeMirror> sourceTypes = typeSystem.lookupSourceTypes(type); CodeTreeBuilder builder = method.createBuilder(); boolean elseIf = false;
private Element createMethodGetSpecializationNode() { TypeMirror returntype = getType(SpecializationNode.class); CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), returntype, "getSpecializationNode"); method.createBuilder().startReturn().string(specializationStartFieldName()).end(); return method; }
private CodeTree wrapInAMethod(CodeTreeBuilder parent, SpecializationGroup group, FrameState frameState, String suffix, CodeTree codeTree) { CodeExecutableElement parentMethod = (CodeExecutableElement) parent.findMethod(); CodeTypeElement parentClass = (CodeTypeElement) parentMethod.getEnclosingElement(); String name = parentMethod.getSimpleName().toString() + "_" + suffix + (boxingSplitIndex++); CodeExecutableElement method = parentClass.add( frameState.createMethod(modifiers(Modifier.PRIVATE), parentMethod.getReturnType(), name, FRAME_VALUE, STATE_VALUE)); CodeTreeBuilder builder = method.createBuilder(); builder.tree(codeTree); method.getThrownTypes().addAll(parentMethod.getThrownTypes()); addExplodeLoop(builder, group); CodeTreeBuilder parentBuilder = parent.create(); parentBuilder.startReturn(); parentBuilder.startCall(method.getSimpleName().toString()); frameState.addReferencesTo(parentBuilder, FRAME_VALUE, STATE_VALUE); parentBuilder.end(); parentBuilder.end(); return parentBuilder.build(); }
private static void generateErrorNode(ProcessorContext context, NodeData node, CodeTypeElement type) { for (ExecutableElement superConstructor : GeneratorUtils.findUserConstructors(node.getTemplateType().asType())) { CodeExecutableElement constructor = GeneratorUtils.createConstructorUsingFields(modifiers(), type, superConstructor); ElementUtils.setVisibility(constructor.getModifiers(), ElementUtils.getVisibility(superConstructor.getModifiers())); List<CodeVariableElement> childParameters = new ArrayList<>(); for (NodeChildData child : node.getChildren()) { childParameters.add(new CodeVariableElement(child.getOriginalType(), child.getName())); } constructor.getParameters().addAll(superConstructor.getParameters().size(), childParameters); type.add(constructor); } for (ExecutableElement method : ElementFilter.methodsIn(context.getEnvironment().getElementUtils().getAllMembers(node.getTemplateType()))) { if (method.getModifiers().contains(Modifier.ABSTRACT) && ElementUtils.getVisibility(method.getModifiers()) != Modifier.PRIVATE) { CodeExecutableElement overrideMethod = CodeExecutableElement.clone(context.getEnvironment(), method); overrideMethod.getModifiers().remove(Modifier.ABSTRACT); List<Message> messages = node.collectMessages(); String message = messages.toString(); message = message.replaceAll("\"", "\\\\\""); message = message.replaceAll("\n", "\\\\n"); overrideMethod.createBuilder().startThrow().startNew(context.getType(RuntimeException.class)).doubleQuote("Truffle DSL compiler errors: " + message).end().end(); type.add(overrideMethod); } } }
private CodeExecutableElement createCreateNodeMethod() { CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), node.getNodeType(), "createNode"); CodeVariableElement arguments = new CodeVariableElement(context.getType(Object.class), "arguments"); method.setVarArgs(true); method.addParameter(arguments); CodeTreeBuilder builder = method.createBuilder(); List<ExecutableElement> signatures = GeneratorUtils.findUserConstructors(createdFactoryElement.asType()); boolean ifStarted = false;
public static CodeExecutableElement createSuperConstructor(ProcessorContext context, TypeElement type, ExecutableElement element) { if (element.getModifiers().contains(Modifier.PRIVATE)) { return null; } CodeExecutableElement executable = CodeExecutableElement.clone(context.getEnvironment(), element); executable.setReturnType(null); executable.setSimpleName(CodeNames.of(type.getSimpleName().toString())); CodeTreeBuilder b = executable.createBuilder(); b.startStatement(); b.startSuperCall(); for (VariableElement v : element.getParameters()) { b.string(v.getSimpleName().toString()); } b.end(); b.end(); return executable; }
private ExecutableElement createAccessChildMethod(NodeChildData child) { if (child.getAccessElement() != null && child.getAccessElement().getModifiers().contains(Modifier.ABSTRACT)) { ExecutableElement getter = (ExecutableElement) child.getAccessElement(); CodeExecutableElement method = CodeExecutableElement.clone(context.getEnvironment(), getter); method.getModifiers().remove(Modifier.ABSTRACT); List<NodeExecutionData> executions = new ArrayList<>(); for (NodeExecutionData execution : node.getChildExecutions()) { if (execution.getChild() == child) { executions.add(execution); } } CodeTreeBuilder builder = method.createBuilder(); if (child.getCardinality().isMany()) { builder.startReturn().startNewArray((ArrayType) child.getOriginalType(), null); for (NodeExecutionData execution : executions) { builder.string(accessNodeField(execution)); } builder.end().end(); } else { for (NodeExecutionData execution : executions) { builder.startReturn().string(accessNodeField(execution)).end(); break; } } return method; } return null; }
for (VariableElement v : method.getParameters()) { if (v.getSimpleName().toString().equals(STATE_VALUE)) { toRemove = v; method.getParameters().remove(toRemove); final CodeTreeBuilder builder = method.createBuilder(); for (SpecializationData implemented : specializations) { if (implemented.getMaximumNumberOfInstances() > 1) { method.getAnnotationMirrors().add(createExplodeLoop()); break; method.getModifiers().add(STATIC);
private CodeExecutableElement createInsertAccessor(boolean array) { CodeTypeParameterElement tVar = new CodeTypeParameterElement("T", context.getType(Node.class)); TypeMirror type = tVar.createMirror(null, null); if (array) { type = new ArrayCodeTypeMirror(type); } CodeExecutableElement insertAccessor = new CodeExecutableElement(modifiers(FINAL), type, INSERT_ACCESSOR_NAME); insertAccessor.getParameters().add(new CodeVariableElement(type, "node")); insertAccessor.getTypeParameters().add(tVar); insertAccessor.createBuilder().startReturn().string("super.insert(node)").end(); return insertAccessor; }