Mercurial > hg > graal-compiler
annotate graal/com.oracle.graal.nodeinfo.processor/src/com/oracle/graal/nodeinfo/processor/GraphNodeGenerator.java @ 16895:06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Mon, 18 Aug 2014 14:04:21 +0200 |
parents | 03a4d382c122 |
children | f90dcdbbb75e |
rev | line source |
---|---|
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
1 /* |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
4 * |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
5 * This code is free software; you can redistribute it and/or modify it |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
6 * under the terms of the GNU General Public License version 2 only, as |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
7 * published by the Free Software Foundation. |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
8 * |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
13 * accompanied this code). |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
14 * |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
15 * You should have received a copy of the GNU General Public License version |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
18 * |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
21 * questions. |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
22 */ |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
23 package com.oracle.graal.nodeinfo.processor; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
24 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
25 import static com.oracle.truffle.dsl.processor.java.ElementUtils.*; |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
26 import static java.util.Arrays.*; |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
27 import static javax.lang.model.element.Modifier.*; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
28 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
29 import java.util.*; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
30 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
31 import javax.annotation.processing.*; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
32 import javax.lang.model.element.*; |
16809
1a8d95626af7
annotate generated Node classes with @GeneratedNode; improved error messages in @NodeInfo annotation processor
Doug Simon <doug.simon@oracle.com>
parents:
16787
diff
changeset
|
33 import javax.lang.model.type.*; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
34 import javax.lang.model.util.*; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
35 |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
36 import com.oracle.graal.nodeinfo.*; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
37 import com.oracle.truffle.dsl.processor.java.*; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
38 import com.oracle.truffle.dsl.processor.java.model.*; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
39 |
16809
1a8d95626af7
annotate generated Node classes with @GeneratedNode; improved error messages in @NodeInfo annotation processor
Doug Simon <doug.simon@oracle.com>
parents:
16787
diff
changeset
|
40 /** |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
41 * Generates the source code for a Node class. |
16809
1a8d95626af7
annotate generated Node classes with @GeneratedNode; improved error messages in @NodeInfo annotation processor
Doug Simon <doug.simon@oracle.com>
parents:
16787
diff
changeset
|
42 */ |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
43 public class GraphNodeGenerator { |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
44 |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
45 final GraphNodeProcessor env; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
46 final TypeElement Input; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
47 final TypeElement OptionalInput; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
48 final TypeElement Successor; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
49 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
50 final TypeElement Node; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
51 final TypeElement NodeInputList; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
52 final TypeElement NodeSuccessorList; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
53 |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
54 public GraphNodeGenerator(GraphNodeProcessor processor) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
55 this.env = processor; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
56 this.Input = getType("com.oracle.graal.graph.Node.Input"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
57 this.OptionalInput = getType("com.oracle.graal.graph.Node.OptionalInput"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
58 this.Successor = getType("com.oracle.graal.graph.Node.Successor"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
59 this.Node = getType("com.oracle.graal.graph.Node"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
60 this.NodeInputList = getType("com.oracle.graal.graph.NodeInputList"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
61 this.NodeSuccessorList = getType("com.oracle.graal.graph.NodeSuccessorList"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
62 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
63 |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
64 /** |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
65 * Returns a type element given a canonical name. |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
66 * |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
67 * @throw {@link NoClassDefFoundError} if a type element does not exist for {@code name} |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
68 */ |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
69 public TypeElement getType(String name) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
70 TypeElement typeElement = env.getProcessingEnv().getElementUtils().getTypeElement(name); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
71 if (typeElement == null) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
72 throw new NoClassDefFoundError(name); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
73 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
74 return typeElement; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
75 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
76 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
77 public ProcessingEnvironment getProcessingEnv() { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
78 return env.getProcessingEnv(); |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
79 } |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
80 |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
81 private static String getGeneratedClassName(TypeElement node) { |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
82 |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
83 TypeElement typeElement = node; |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
84 |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
85 String newClassName = typeElement.getSimpleName().toString() + "Gen"; |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
86 Element enclosing = typeElement.getEnclosingElement(); |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
87 while (enclosing != null) { |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
88 if (enclosing.getKind() == ElementKind.CLASS || enclosing.getKind() == ElementKind.INTERFACE) { |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
89 if (enclosing.getModifiers().contains(Modifier.PRIVATE)) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
90 throw new ElementException(enclosing, "%s %s cannot be private", enclosing.getKind().name().toLowerCase(), enclosing); |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
91 } |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
92 newClassName = enclosing.getSimpleName() + "_" + newClassName; |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
93 } else { |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
94 assert enclosing.getKind() == ElementKind.PACKAGE; |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
95 } |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
96 enclosing = enclosing.getEnclosingElement(); |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
97 } |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
98 return newClassName; |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
99 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
100 |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
101 public class FieldScanner { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
102 /** |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
103 * @param field |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
104 * @param isOptional |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
105 * @param isList |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
106 * @return true if field scanning should continue |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
107 */ |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
108 public boolean scanInputField(VariableElement field, boolean isOptional, boolean isList) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
109 return true; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
110 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
111 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
112 /** |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
113 * @param field |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
114 * @param isList |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
115 * @return true if field scanning should continue |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
116 */ |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
117 public boolean scanSuccessorField(VariableElement field, boolean isList) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
118 return true; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
119 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
120 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
121 /** |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
122 * @param field |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
123 * @return true if field scanning should continue |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
124 */ |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
125 public boolean scanDataField(VariableElement field) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
126 return true; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
127 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
128 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
129 |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
130 public boolean isAssignableWithErasure(Element from, Element to) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
131 Types types = env.getProcessingEnv().getTypeUtils(); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
132 TypeMirror fromType = types.erasure(from.asType()); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
133 TypeMirror toType = types.erasure(to.asType()); |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
134 return types.isAssignable(fromType, toType); |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
135 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
136 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
137 public void scanFields(TypeElement node, FieldScanner scanner) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
138 TypeElement currentClazz = node; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
139 do { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
140 for (VariableElement field : ElementFilter.fieldsIn(currentClazz.getEnclosedElements())) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
141 Set<Modifier> modifiers = field.getModifiers(); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
142 if (modifiers.contains(STATIC) || modifiers.contains(TRANSIENT)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
143 continue; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
144 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
145 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
146 List<? extends AnnotationMirror> annotations = field.getAnnotationMirrors(); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
147 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
148 boolean isNonOptionalInput = findAnnotationMirror(annotations, Input) != null; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
149 boolean isOptionalInput = findAnnotationMirror(annotations, OptionalInput) != null; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
150 boolean isSuccessor = findAnnotationMirror(annotations, Successor) != null; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
151 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
152 if (isNonOptionalInput || isOptionalInput) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
153 if (findAnnotationMirror(annotations, Successor) != null) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
154 throw new ElementException(field, "Field cannot be both input and successor"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
155 } else if (isNonOptionalInput && isOptionalInput) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
156 throw new ElementException(field, "Inputs must be either optional or non-optional"); |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
157 } else if (isAssignableWithErasure(field, NodeInputList)) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
158 if (!modifiers.contains(FINAL)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
159 throw new ElementException(field, "Input list field must be final"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
160 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
161 if (modifiers.contains(PUBLIC)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
162 throw new ElementException(field, "Input list field must not be public"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
163 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
164 if (!scanner.scanInputField(field, isOptionalInput, true)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
165 return; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
166 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
167 } else { |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
168 if (!isAssignableWithErasure(field, Node) && field.getKind() == ElementKind.INTERFACE) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
169 throw new ElementException(field, "Input field type must be an interface or assignable to Node"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
170 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
171 if (modifiers.contains(FINAL)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
172 throw new ElementException(field, "Input field must not be final"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
173 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
174 // if (modifiers.contains(PRIVATE) || modifiers.contains(PUBLIC) || modifiers.contains(PROTECTED)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
175 // throw new ElementException(field, "Input field must be package-private"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
176 // } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
177 if (!modifiers.contains(PRIVATE)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
178 throw new ElementException(field, "Input field must be private"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
179 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
180 if (!scanner.scanInputField(field, isOptionalInput, false)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
181 return; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
182 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
183 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
184 } else if (isSuccessor) { |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
185 if (isAssignableWithErasure(field, NodeSuccessorList)) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
186 if (!modifiers.contains(FINAL)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
187 throw new ElementException(field, "Successor list field must be final"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
188 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
189 if (modifiers.contains(PUBLIC)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
190 throw new ElementException(field, "Successor list field must not be public"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
191 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
192 if (!scanner.scanSuccessorField(field, true)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
193 return; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
194 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
195 } else { |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
196 if (!isAssignableWithErasure(field, Node)) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
197 throw new ElementException(field, "Successor field must be a Node type"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
198 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
199 if (modifiers.contains(FINAL)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
200 throw new ElementException(field, "Successor field must not be final"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
201 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
202 // if (modifiers.contains(PRIVATE) || modifiers.contains(PUBLIC) || modifiers.contains(PROTECTED)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
203 // throw new ElementException(field, "Successor field must be package-private"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
204 // } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
205 if (!modifiers.contains(PRIVATE)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
206 throw new ElementException(field, "Successor field must be private"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
207 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
208 if (!scanner.scanSuccessorField(field, false)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
209 return; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
210 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
211 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
212 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
213 } else { |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
214 if (isAssignableWithErasure(field, Node) && !field.getSimpleName().contentEquals("Null")) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
215 throw new ElementException(field, "Suspicious Node field: " + field); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
216 } |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
217 if (isAssignableWithErasure(field, NodeInputList)) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
218 throw new ElementException(field, "Suspicious NodeInputList field"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
219 } |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
220 if (isAssignableWithErasure(field, NodeSuccessorList)) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
221 throw new ElementException(field, "Suspicious NodeSuccessorList field"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
222 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
223 if (!scanner.scanDataField(field)) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
224 return; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
225 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
226 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
227 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
228 currentClazz = getSuperType(currentClazz); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
229 } while (!isObject(getSuperType(currentClazz).asType())); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
230 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
231 |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
232 /** |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
233 * Determines if two parameter lists contain the |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
234 * {@linkplain Types#isSameType(TypeMirror, TypeMirror) same} types. |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
235 */ |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
236 private boolean parametersMatch(List<? extends VariableElement> p1, List<? extends VariableElement> p2) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
237 if (p1.size() == p2.size()) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
238 for (int i = 0; i < p1.size(); i++) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
239 if (!env.getProcessingEnv().getTypeUtils().isSameType(p1.get(i).asType(), p2.get(i).asType())) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
240 return false; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
241 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
242 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
243 return true; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
244 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
245 return false; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
246 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
247 |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
248 /** |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
249 * Searches a type for a method based on a given name and parameter types. |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
250 */ |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
251 public ExecutableElement findMethod(TypeElement type, String name, List<? extends VariableElement> parameters) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
252 List<? extends ExecutableElement> methods = ElementFilter.methodsIn(type.getEnclosedElements()); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
253 for (ExecutableElement method : methods) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
254 if (method.getSimpleName().toString().equals(name)) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
255 if (parametersMatch(method.getParameters(), parameters)) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
256 return method; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
257 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
258 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
259 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
260 return null; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
261 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
262 |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
263 public CodeCompilationUnit process(TypeElement node) { |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
264 |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
265 CodeCompilationUnit compilationUnit = new CodeCompilationUnit(); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
266 |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
267 PackageElement packageElement = ElementUtils.findPackageElement(node); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
268 |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
269 String newClassName = getGeneratedClassName(node); |
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
270 |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
271 CodeTypeElement nodeGenElement = new CodeTypeElement(modifiers(), ElementKind.CLASS, packageElement, newClassName); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
272 |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
273 nodeGenElement.setSuperClass(node.asType()); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
274 |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
275 for (ExecutableElement constructor : ElementFilter.constructorsIn(node.getEnclosedElements())) { |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
276 if (constructor.getModifiers().contains(PUBLIC)) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
277 throw new ElementException(constructor, "Node class constructor must not be public"); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
278 } |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
279 |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
280 checkFactoryMethodExists(node, newClassName, constructor); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
281 |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
282 CodeExecutableElement subConstructor = createConstructor(nodeGenElement, constructor); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
283 subConstructor.getModifiers().removeAll(Arrays.asList(PUBLIC, PRIVATE, PROTECTED)); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
284 nodeGenElement.add(subConstructor); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
285 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
286 |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
287 DeclaredType generatedNode = (DeclaredType) ElementUtils.getType(getProcessingEnv(), GeneratedNode.class); |
16809
1a8d95626af7
annotate generated Node classes with @GeneratedNode; improved error messages in @NodeInfo annotation processor
Doug Simon <doug.simon@oracle.com>
parents:
16787
diff
changeset
|
288 CodeAnnotationMirror generatedByMirror = new CodeAnnotationMirror(generatedNode); |
16841
cbd42807a31f
moved NodeInfo and friends into separate com.oracle.graal.nodeinfo project so that annotation processor can be applied to the base Node class
Doug Simon <doug.simon@oracle.com>
parents:
16835
diff
changeset
|
289 generatedByMirror.setElementValue(generatedByMirror.findExecutableElement("value"), new CodeAnnotationValue(node.asType())); |
16809
1a8d95626af7
annotate generated Node classes with @GeneratedNode; improved error messages in @NodeInfo annotation processor
Doug Simon <doug.simon@oracle.com>
parents:
16787
diff
changeset
|
290 nodeGenElement.getAnnotationMirrors().add(generatedByMirror); |
1a8d95626af7
annotate generated Node classes with @GeneratedNode; improved error messages in @NodeInfo annotation processor
Doug Simon <doug.simon@oracle.com>
parents:
16787
diff
changeset
|
291 |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
292 nodeGenElement.add(createIsLeafNodeMethod(node)); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
293 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
294 compilationUnit.add(nodeGenElement); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
295 return compilationUnit; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
296 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
297 |
16895
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
298 /** |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
299 * Checks that a public static factory method named {@code "create"} exists in {@code node} |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
300 * whose signature matches that of a given constructor. |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
301 * |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
302 * @throws ElementException if the check fails |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
303 */ |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
304 private void checkFactoryMethodExists(TypeElement node, String newClassName, ExecutableElement constructor) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
305 ExecutableElement create = findMethod(node, "create", constructor.getParameters()); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
306 if (create == null) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
307 Formatter f = new Formatter(); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
308 f.format("public static %s create(", node.getSimpleName()); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
309 String sep = ""; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
310 Formatter callArgs = new Formatter(); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
311 for (VariableElement v : constructor.getParameters()) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
312 f.format("%s%s %s", sep, ElementUtils.getSimpleName(v.asType()), v.getSimpleName()); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
313 callArgs.format("%s%s", sep, v.getSimpleName()); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
314 sep = ", "; |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
315 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
316 f.format(") { return new %s(%s); }", newClassName, callArgs); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
317 throw new ElementException(constructor, "Missing Node class factory method '%s'", f); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
318 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
319 if (!create.getModifiers().containsAll(asList(PUBLIC, STATIC))) { |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
320 throw new ElementException(constructor, "Node class factory method must be public and static"); |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
321 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
322 } |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
323 |
06c15e88d383
added factory method to all Node classes; replaced Node classes instantiation with calls to factory methods; replaced identity tests on Node classes with ' == <node class>.getGenClass()' idiom
Doug Simon <doug.simon@oracle.com>
parents:
16893
diff
changeset
|
324 private CodeExecutableElement createConstructor(TypeElement type, ExecutableElement element) { |
16835
b3a60e14ec37
generated Node classes are prefixed with the names of classes enclosing the source classes
Doug Simon <doug.simon@oracle.com>
parents:
16809
diff
changeset
|
325 CodeExecutableElement executable = CodeExecutableElement.clone(getProcessingEnv(), element); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
326 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
327 // to create a constructor we have to set the return type to null.(TODO needs fix) |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
328 executable.setReturnType(null); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
329 // we have to set the name manually otherwise <init> is inferred (TODO needs fix) |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
330 executable.setSimpleName(CodeNames.of(type.getSimpleName().toString())); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
331 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
332 CodeTreeBuilder b = executable.createBuilder(); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
333 b.startStatement().startSuperCall(); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
334 for (VariableElement v : element.getParameters()) { |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
335 b.string(v.getSimpleName().toString()); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
336 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
337 b.end().end(); |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
338 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
339 return executable; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
340 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
341 |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
342 public ExecutableElement createIsLeafNodeMethod(TypeElement node) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
343 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC), ElementUtils.getType(getProcessingEnv(), boolean.class), "isLeafNode"); |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
344 boolean[] isLeafNode = {true}; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
345 scanFields(node, new FieldScanner() { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
346 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
347 @Override |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
348 public boolean scanInputField(VariableElement field, boolean isOptional, boolean isList) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
349 isLeafNode[0] = false; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
350 return false; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
351 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
352 |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
353 @Override |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
354 public boolean scanSuccessorField(VariableElement field, boolean isList) { |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
355 isLeafNode[0] = false; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
356 return false; |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
357 } |
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
358 }); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
359 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
360 CodeTreeBuilder builder = method.createBuilder(); |
16893
03a4d382c122
introduced ElementException; don't process abstract Node classes; generate isLeafNode method
Doug Simon <doug.simon@oracle.com>
parents:
16847
diff
changeset
|
361 builder.startReturn().string(String.valueOf(isLeafNode[0])).end(); |
16787
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
362 |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
363 return method; |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
364 } |
9346cbeeded3
Added initial version of the graal graph nodes annotation processor.
Christian Humer <christian.humer@gmail.com>
parents:
diff
changeset
|
365 } |