Mercurial > hg > graal-jvmci-8

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/AnnotationProcessor.java @ 16759:23415229349b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle-DSL: new package structure.
author Christian Humer <christian.humer@gmail.com>
date Mon, 11 Aug 2014 15:57:14 +0200
parents bd28da642eea
children 45c8f64978d6
comparison
equal deleted inserted replaced
16758:c5f8eeb3cbc8 16759:23415229349b
28 import javax.annotation.processing.*; 28 import javax.annotation.processing.*;
29 import javax.lang.model.element.*; 29 import javax.lang.model.element.*;
30 import javax.lang.model.type.*; 30 import javax.lang.model.type.*;
31 import javax.tools.*; 31 import javax.tools.*;
32 32
33 import com.oracle.truffle.dsl.processor.ast.*; 33 import com.oracle.truffle.dsl.processor.generator.*;
34 import com.oracle.truffle.dsl.processor.codewriter.*; 34 import com.oracle.truffle.dsl.processor.java.*;
35 import com.oracle.truffle.dsl.processor.compiler.*; 35 import com.oracle.truffle.dsl.processor.java.compiler.*;
36 import com.oracle.truffle.dsl.processor.node.*; 36 import com.oracle.truffle.dsl.processor.java.model.*;
37 import com.oracle.truffle.dsl.processor.template.*; 37 import com.oracle.truffle.dsl.processor.java.transform.*;
38 import com.oracle.truffle.dsl.processor.model.*;
39 import com.oracle.truffle.dsl.processor.parser.*;
38 40
39 /** 41 /**
40 * THIS IS NOT PUBLIC API. 42 * THIS IS NOT PUBLIC API.
41 */ 43 */
42 class AnnotationProcessor<M extends Template> { 44 class AnnotationProcessor<M extends Template> {
43 45
44 private final AbstractParser<M> parser; 46 private final AbstractParser<M> parser;
45 private final CompilationUnitFactory<M> factory; 47 private final AbstractCompilationUnitFactory<M> factory;
46 48
47 private final Set<String> processedElements = new HashSet<>(); 49 private final Set<String> processedElements = new HashSet<>();
48 50
49 public AnnotationProcessor(AbstractParser<M> parser, CompilationUnitFactory<M> factory) { 51 public AnnotationProcessor(AbstractParser<M> parser, AbstractCompilationUnitFactory<M> factory) {
50 this.parser = parser; 52 this.parser = parser;
51 this.factory = factory; 53 this.factory = factory;
52 } 54 }
53 55
54 public AbstractParser<M> getParser() { 56 public AbstractParser<M> getParser() {
55 return parser; 57 return parser;
56 } 58 }
57 59
58 @SuppressWarnings({"unchecked"}) 60 @SuppressWarnings({"unchecked"})
59 public void process(RoundEnvironment env, Element element, boolean callback) { 61 public void process(Element element, boolean callback) {
60 // since it is not guaranteed to be called only once by the compiler 62 // since it is not guaranteed to be called only once by the compiler
61 // we check for already processed elements to avoid errors when writing files. 63 // we check for already processed elements to avoid errors when writing files.
62 if (!callback && element instanceof TypeElement) { 64 if (!callback && element instanceof TypeElement) {
63 String qualifiedName = Utils.getQualifiedName((TypeElement) element); 65 String qualifiedName = ElementUtils.getQualifiedName((TypeElement) element);
64 if (processedElements.contains(qualifiedName)) { 66 if (processedElements.contains(qualifiedName)) {
65 return; 67 return;
66 } 68 }
67 processedElements.add(qualifiedName); 69 processedElements.add(qualifiedName);
68 } 70 }
73 M model = (M) context.getTemplate(type.asType(), false); 75 M model = (M) context.getTemplate(type.asType(), false);
74 boolean firstRun = !context.containsTemplate(type); 76 boolean firstRun = !context.containsTemplate(type);
75 77
76 if (firstRun || !callback) { 78 if (firstRun || !callback) {
77 context.registerTemplate(type, null); 79 context.registerTemplate(type, null);
78 model = parser.parse(env, element); 80 model = parser.parse(element);
79 context.registerTemplate(type, model); 81 context.registerTemplate(type, model);
80 82
81 if (model != null) { 83 if (model != null) {
82 CodeCompilationUnit unit = factory.process(null, model); 84 CodeCompilationUnit unit = factory.process(null, model);
83 patchGeneratedTypes(unit);
84 unit.setGeneratorAnnotationMirror(model.getTemplateTypeAnnotation()); 85 unit.setGeneratorAnnotationMirror(model.getTemplateTypeAnnotation());
85 unit.setGeneratorElement(model.getTemplateType()); 86 unit.setGeneratorElement(model.getTemplateType());
86 87
87 DeclaredType overrideType = (DeclaredType) context.getType(Override.class); 88 DeclaredType overrideType = (DeclaredType) context.getType(Override.class);
88 DeclaredType unusedType = (DeclaredType) context.getType(SuppressWarnings.class); 89 DeclaredType unusedType = (DeclaredType) context.getType(SuppressWarnings.class);
92 if (!callback) { 93 if (!callback) {
93 unit.accept(new CodeWriter(context.getEnvironment(), element), null); 94 unit.accept(new CodeWriter(context.getEnvironment(), element), null);
94 } 95 }
95 } 96 }
96 } 97 }
97 }
98
99 private static void patchGeneratedTypes(CodeCompilationUnit unit) {
100 final Map<String, CodeTypeElement> classes = new HashMap<>();
101
102 unit.accept(new CodeElementScanner<Void, Void>() {
103 @Override
104 public Void visitType(CodeTypeElement e, Void p) {
105 classes.put(e.getSimpleName().toString(), e);
106 return super.visitType(e, p);
107 }
108
109 }, null);
110
111 unit.accept(new CodeElementScanner<Void, Void>() {
112 @Override
113 public Void visitExecutable(CodeExecutableElement e, Void p) {
114 if (e.getReturnType() instanceof GeneratedTypeMirror) {
115 e.setReturnType(patchType(e.getReturnType()));
116 }
117 for (VariableElement element : e.getParameters()) {
118 if (element instanceof CodeVariableElement) {
119 CodeVariableElement var = ((CodeVariableElement) element);
120 if (var.getType() instanceof GeneratedTypeMirror) {
121 var.setType(patchType(var.getType()));
122 }
123 }
124 }
125 return super.visitExecutable(e, p);
126 }
127
128 @Override
129 public void visitTree(CodeTree e, Void p) {
130 if (e.getType() instanceof GeneratedTypeMirror) {
131 e.setType(patchType(e.asType()));
132 }
133 }
134
135 private TypeMirror patchType(TypeMirror typeMirror) {
136 assert typeMirror instanceof GeneratedTypeMirror;
137 GeneratedTypeMirror type = (GeneratedTypeMirror) typeMirror;
138 CodeTypeElement generatedType = classes.get(Utils.fromTypeMirror(type).getSimpleName().toString());
139 if (generatedType == null) {
140 return type;
141 }
142 return generatedType.asType();
143 }
144 }, null);
145
146 } 98 }
147 99
148 private static class CodeWriter extends AbstractCodeWriter { 100 private static class CodeWriter extends AbstractCodeWriter {
149 101
150 private final Element originalElement; 102 private final Element originalElement;