ProcessorContext context = ProcessorContext.getInstance(); TypeElement type = (TypeElement) element; M model = (M) context.getTemplate(type.asType(), false); boolean firstRun = !context.containsTemplate(type); context.registerTemplate(type, null); model = parser.parse(element); context.registerTemplate(type, model); unit = factory.create(ProcessorContext.getInstance(), model); } catch (Throwable e) { throw new RuntimeException(String.format("Failed to write code for %s. Parserdump:%s.", ElementUtils.getQualifiedName(type), ""), e); unit.setGeneratorElement(model.getTemplateType()); DeclaredType overrideType = (DeclaredType) context.getType(Override.class); DeclaredType unusedType = (DeclaredType) context.getType(SuppressWarnings.class); unit.accept(new GenerateOverrideVisitor(overrideType), null); unit.accept(new FixWarningsVisitor(context.getEnvironment(), unusedType, overrideType), null); unit.accept(new CodeWriter(context.getEnvironment(), element), null);
private CodeAnnotationMirror createExplodeLoop() { DeclaredType explodeLoopType = context.getDeclaredType(ExplodeLoop.class); CodeAnnotationMirror explodeLoop = new CodeAnnotationMirror(explodeLoopType); DeclaredType loopExplosionKind = context.getDeclaredType(ExplodeLoop.LoopExplosionKind.class); if (loopExplosionKind != null) { VariableElement kindValue = ElementUtils.findVariableElement(loopExplosionKind, "FULL_EXPLODE_UNTIL_RETURN"); if (kindValue != null) { explodeLoop.setElementValue(ElementUtils.findExecutableElement(explodeLoopType, "kind"), new CodeAnnotationValue(kindValue)); } } return explodeLoop; }
continue; if (ElementUtils.findAnnotationMirror(context.getEnvironment(), method, Specialization.class) != null) { continue; ExecutableTypeData executableType = new ExecutableTypeData(node, method, signatureSize, context.getFrameTypes());
public AbstractParser() { this.context = ProcessorContext.getInstance(); this.processingEnv = context.getEnvironment(); this.log = context.getLog(); }
public static boolean isSubtype(TypeMirror type1, TypeMirror type2) { if (type1 instanceof CodeTypeMirror || type2 instanceof CodeTypeMirror) { throw new UnsupportedOperationException(); } return ProcessorContext.getInstance().getEnvironment().getTypeUtils().isSubtype(type1, type2); }
public static boolean isAssignable(TypeMirror from, TypeMirror to) { if (typeEquals(from, to)) { return true; } else if (isVoid(to)) { return true; } else if (isObject(to)) { return true; } ProcessorContext context = ProcessorContext.getInstance(); if (!(from instanceof CodeTypeMirror) && !(to instanceof CodeTypeMirror)) { return context.getEnvironment().getTypeUtils().isAssignable(context.reloadType(from), context.reloadType(to)); } else { return isAssignableImpl(from, to); } }
ProcessorContext context = new ProcessorContext(processingEnv, null); ProcessorContext.setThreadLocalInstance(context); DeclaredType instrumentableNode = context.getDeclaredType(InstrumentableNode.class); ExecutableElement createWrapper = ElementUtils.findExecutableElement(instrumentableNode, CREATE_WRAPPER_NAME); continue; if (!ElementUtils.isAssignable(element.asType(), context.getType(Node.class))) { emitError(element, String.format("Classes annotated with @%s must extend %s.", GenerateWrapper.class.getSimpleName(), Node.class.getSimpleName())); continue; AnnotationMirror generateWrapperMirror = ElementUtils.findAnnotationMirror(element.getAnnotationMirrors(), context.getType(GenerateWrapper.class)); if (generateWrapperMirror == null) { continue; continue; DeclaredType overrideType = (DeclaredType) context.getType(Override.class); DeclaredType unusedType = (DeclaredType) context.getType(SuppressWarnings.class); unit.accept(new GenerateOverrideVisitor(overrideType), null); unit.accept(new FixWarningsVisitor(context.getEnvironment(), unusedType, overrideType), null); unit.accept(new CodeWriter(context.getEnvironment(), element), null); } catch (Throwable e) { ProcessorContext.setThreadLocalInstance(null);
private void generateOptionDescriptor(OptionsInfo info) { Element element = info.type; ProcessorContext context = ProcessorContext.getInstance(); CodeTypeElement unit = generateDescriptors(context, element, info); DeclaredType overrideType = (DeclaredType) context.getType(Override.class); DeclaredType unusedType = (DeclaredType) context.getType(SuppressWarnings.class); unit.accept(new GenerateOverrideVisitor(overrideType), null); unit.accept(new FixWarningsVisitor(context.getEnvironment(), unusedType, overrideType), null); try { unit.accept(new CodeWriter(context.getEnvironment(), element), null); } catch (RuntimeException e) { if (e.getCause() instanceof FilerException) { // ignore spurious errors of source file already created in Eclipse. if (e.getCause().getMessage().startsWith("Source file already created")) { return; } } } }
private NodeData parseNode(TypeElement originalTemplateType) { TypeElement templateType = ElementUtils.fromTypeMirror(context.reloadTypeElement(originalTemplateType)); if (!ElementUtils.isAssignable(templateType.asType(), context.getTruffleTypes().getNode())) { return null; node.getChildren().addAll(parseChildren(lookupTypes, members)); node.getChildExecutions().addAll(parseExecutions(node.getFields(), node.getChildren(), members)); node.getExecutableTypes().addAll(parseExecutableTypeData(node, members, node.getSignatureSize(), context.getFrameTypes(), false));
public static TypeMirror getCommonSuperType(ProcessorContext context, Collection<TypeMirror> types) { if (types.isEmpty()) { return context.getType(Object.class); } Iterator<TypeMirror> typesIterator = types.iterator(); TypeMirror prev = typesIterator.next(); while (typesIterator.hasNext()) { prev = getCommonSuperType(context, prev, typesIterator.next()); } return prev; }
private void verifyExpectedMessages(ProcessorContext context, Log log, List<Message> msgs) { TypeElement expectError = context.getTruffleTypes().getExpectError(); if (expectError != null) { Element element = getMessageElement(); if (element != null) { AnnotationMirror mirror = ElementUtils.findAnnotationMirror(element.getAnnotationMirrors(), expectError.asType()); if (mirror != null) { List<String> values = ElementUtils.getAnnotationValueList(String.class, mirror, "value"); if (values == null) { values = Collections.emptyList(); } if (values.size() != msgs.size()) { log.message(Kind.ERROR, element, mirror, ElementUtils.getAnnotationValue(mirror, "value"), String.format("Error count expected %s but was %s.", values.size(), msgs.size())); } } } } }
return true; ProcessorContext context = new ProcessorContext(processingEnv, null); ProcessorContext.setThreadLocalInstance(context); try { Map<Element, OptionsInfo> map = new HashMap<>(); ProcessorContext.setThreadLocalInstance(null);
public static List<AnnotationMirror> collectAnnotations(ProcessorContext context, AnnotationMirror markerAnnotation, String elementName, Element element, Class<? extends Annotation> annotationClass) { List<AnnotationMirror> result = new ArrayList<>(); if (markerAnnotation != null) { result.addAll(ElementUtils.getAnnotationValueList(AnnotationMirror.class, markerAnnotation, elementName)); } AnnotationMirror explicit = ElementUtils.findAnnotationMirror(context.getEnvironment(), element, annotationClass); if (explicit != null) { result.add(explicit); } return result; }
static CodeTree createTransferToInterpreterAndInvalidate() { ProcessorContext context = ProcessorContext.getInstance(); CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startStatement().startStaticCall(context.getType(CompilerDirectives.class), "transferToInterpreterAndInvalidate").end().end(); return builder.build(); }
private static void setFieldCompilationFinal(CodeVariableElement field, int dimensions) { if (field.getModifiers().contains(Modifier.FINAL) && dimensions <= 0) { // no need for the compilation final annotation. return; } CodeAnnotationMirror annotation = new CodeAnnotationMirror(ProcessorContext.getInstance().getDeclaredType(CompilationFinal.class)); if (dimensions > 0 || field.getType().getKind() == TypeKind.ARRAY) { annotation.setElementValue(annotation.findExecutableElement("dimensions"), new CodeAnnotationValue(dimensions < 0 ? 0 : dimensions)); } field.getAnnotationMirrors().add(annotation); }
public CodeTypeElement create() { String typeName = typeName(forType); TypeMirror baseType = context.getType(Object.class); CodeTypeElement clazz = GeneratorUtils.createClass(typeSystem, null, modifiers(PUBLIC, FINAL, STATIC), typeName, baseType); for (TypeMirror sourceType : sourceTypes) { CodeVariableElement hasSeen = new CodeVariableElement(modifiers(PUBLIC), context.getType(boolean.class), seenFieldName(sourceType)); hasSeen.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(CompilationFinal.class))); clazz.add(hasSeen); } clazz.add(createConstructor(clazz)); if (isTypeBoxingOptimized(options.monomorphicTypeBoxingOptimization(), forType)) { clazz.add(createIsMonomorphic()); } clazz.add(createCast(false)); clazz.add(createCast(true)); clazz.add(createCheck()); clazz.add(createMerge(clazz)); clazz.add(createCreate(clazz)); return clazz; }
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; }
TypeMirror cacheAnnotation = context.getType(Cached.class); List<TypeMirror> frameTypes = context.getFrameTypes();
private Element createGetSuppliedChildrenMethod() { ArrayType nodeArray = context.getEnvironment().getTypeUtils().getArrayType(getType(Node.class)); CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), nodeArray, "getSuppliedChildren"); method.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(Override.class))); CodeTreeBuilder builder = method.createBuilder(); builder.startReturn().tree(createGetSuppliedChildren()).end(); return method; }
builder.staticReference(context.getTruffleTypes().getDslMetadata(), EMPTY_CLASS_ARRAY); } else { builder.startNewArray(new ArrayCodeTypeMirror(context.getType(Class.class)), null); for (NodeExecutionData execution : node.getChildExecutions()) { builder.typeLiteral(execution.getNodeType()); builder.startNewArray(new ArrayCodeTypeMirror(new ArrayCodeTypeMirror(context.getType(Class.class))), null); List<ExecutableElement> constructors = GeneratorUtils.findUserConstructors(createdFactoryElement.asType()); for (ExecutableElement constructor : constructors) { builder.startGroup(); if (constructor.getParameters().isEmpty()) { builder.staticReference(context.getTruffleTypes().getDslMetadata(), EMPTY_CLASS_ARRAY); } else { builder.startNewArray(new ArrayCodeTypeMirror(context.getType(Class.class)), null); for (VariableElement var : constructor.getParameters()) { builder.typeLiteral(var.asType());