Mercurial > hg > graal-jvmci-8
comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/model/TemplateMethod.java @ 16759:23415229349b
Truffle-DSL: new package structure.
author | Christian Humer <christian.humer@gmail.com> |
---|---|
date | Mon, 11 Aug 2014 15:57:14 +0200 |
parents | graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/template/TemplateMethod.java@bd28da642eea |
children | 2db61eddcb97 |
comparison
equal
deleted
inserted
replaced
16758:c5f8eeb3cbc8 | 16759:23415229349b |
---|---|
1 /* | |
2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. | |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
20 * or visit www.oracle.com if you need additional information or have any | |
21 * questions. | |
22 */ | |
23 package com.oracle.truffle.dsl.processor.model; | |
24 | |
25 import java.util.*; | |
26 | |
27 import javax.lang.model.element.*; | |
28 import javax.lang.model.type.*; | |
29 | |
30 import com.oracle.truffle.dsl.processor.java.*; | |
31 import com.oracle.truffle.dsl.processor.util.*; | |
32 | |
33 /** | |
34 * Note: this class has a natural ordering that is inconsistent with equals. | |
35 */ | |
36 public class TemplateMethod extends MessageContainer implements Comparable<TemplateMethod> { | |
37 | |
38 public static final int NO_NATURAL_ORDER = -1; | |
39 | |
40 private String id; | |
41 private final Template template; | |
42 private final int naturalOrder; | |
43 private final MethodSpec specification; | |
44 private final ExecutableElement method; | |
45 private final AnnotationMirror markerAnnotation; | |
46 private Parameter returnType; | |
47 private List<Parameter> parameters; | |
48 | |
49 public TemplateMethod(String id, int naturalOrder, Template template, MethodSpec specification, ExecutableElement method, AnnotationMirror markerAnnotation, Parameter returnType, | |
50 List<Parameter> parameters) { | |
51 this.template = template; | |
52 this.specification = specification; | |
53 this.naturalOrder = naturalOrder; | |
54 this.method = method; | |
55 this.markerAnnotation = markerAnnotation; | |
56 this.returnType = returnType; | |
57 this.parameters = new ArrayList<>(); | |
58 for (Parameter param : parameters) { | |
59 Parameter newParam = new Parameter(param); | |
60 this.parameters.add(newParam); | |
61 newParam.setMethod(this); | |
62 } | |
63 this.id = id; | |
64 } | |
65 | |
66 public int getNaturalOrder() { | |
67 return naturalOrder; | |
68 } | |
69 | |
70 public TemplateMethod(TemplateMethod method) { | |
71 this(method.id, method.naturalOrder, method.template, method.specification, method.method, method.markerAnnotation, method.returnType, method.parameters); | |
72 getMessages().addAll(method.getMessages()); | |
73 } | |
74 | |
75 public TemplateMethod(TemplateMethod method, ExecutableElement executable) { | |
76 this(method.id, method.naturalOrder, method.template, method.specification, executable, method.markerAnnotation, method.returnType, method.parameters); | |
77 getMessages().addAll(method.getMessages()); | |
78 } | |
79 | |
80 public void setParameters(List<Parameter> parameters) { | |
81 this.parameters = parameters; | |
82 } | |
83 | |
84 @Override | |
85 public Element getMessageElement() { | |
86 return method; | |
87 } | |
88 | |
89 @Override | |
90 public AnnotationMirror getMessageAnnotation() { | |
91 return markerAnnotation; | |
92 } | |
93 | |
94 @Override | |
95 protected List<MessageContainer> findChildContainers() { | |
96 return Collections.emptyList(); | |
97 } | |
98 | |
99 public void setId(String id) { | |
100 this.id = id; | |
101 } | |
102 | |
103 public String getId() { | |
104 return id; | |
105 } | |
106 | |
107 public Template getTemplate() { | |
108 return template; | |
109 } | |
110 | |
111 public MethodSpec getSpecification() { | |
112 return specification; | |
113 } | |
114 | |
115 public Parameter getReturnType() { | |
116 return returnType; | |
117 } | |
118 | |
119 public void replaceParameter(String localName, Parameter newParameter) { | |
120 if (returnType.getLocalName().equals(localName)) { | |
121 returnType = newParameter; | |
122 returnType.setMethod(this); | |
123 } | |
124 | |
125 for (ListIterator<Parameter> iterator = parameters.listIterator(); iterator.hasNext();) { | |
126 Parameter parameter = iterator.next(); | |
127 if (parameter.getLocalName().equals(localName)) { | |
128 iterator.set(newParameter); | |
129 newParameter.setMethod(this); | |
130 } | |
131 } | |
132 } | |
133 | |
134 public List<Parameter> getRequiredParameters() { | |
135 List<Parameter> requiredParameters = new ArrayList<>(); | |
136 for (Parameter parameter : getParameters()) { | |
137 if (getSpecification().getRequired().contains(parameter.getSpecification())) { | |
138 requiredParameters.add(parameter); | |
139 } | |
140 } | |
141 return requiredParameters; | |
142 } | |
143 | |
144 public Iterable<Parameter> getSignatureParameters() { | |
145 return new FilteredIterable<>(getParameters(), new Predicate<Parameter>() { | |
146 public boolean evaluate(Parameter value) { | |
147 return value.getSpecification().isSignature(); | |
148 } | |
149 }); | |
150 } | |
151 | |
152 public List<Parameter> getParameters() { | |
153 return parameters; | |
154 } | |
155 | |
156 public List<Parameter> findParameters(ParameterSpec spec) { | |
157 List<Parameter> foundParameters = new ArrayList<>(); | |
158 for (Parameter param : getReturnTypeAndParameters()) { | |
159 if (param.getSpecification().getName().equals(spec.getName())) { | |
160 foundParameters.add(param); | |
161 } | |
162 } | |
163 return foundParameters; | |
164 } | |
165 | |
166 public Parameter findParameter(String valueName) { | |
167 for (Parameter param : getReturnTypeAndParameters()) { | |
168 if (param.getLocalName().equals(valueName)) { | |
169 return param; | |
170 } | |
171 } | |
172 return null; | |
173 } | |
174 | |
175 public List<Parameter> getReturnTypeAndParameters() { | |
176 List<Parameter> allParameters = new ArrayList<>(getParameters().size() + 1); | |
177 if (getReturnType() != null) { | |
178 allParameters.add(getReturnType()); | |
179 } | |
180 allParameters.addAll(getParameters()); | |
181 return Collections.unmodifiableList(allParameters); | |
182 } | |
183 | |
184 public boolean canBeAccessedByInstanceOf(TypeMirror type) { | |
185 TypeMirror methodType = ElementUtils.findNearestEnclosingType(getMethod()).asType(); | |
186 return ElementUtils.isAssignable(type, methodType) || ElementUtils.isAssignable(methodType, type); | |
187 } | |
188 | |
189 public ExecutableElement getMethod() { | |
190 return method; | |
191 } | |
192 | |
193 public String getMethodName() { | |
194 if (getMethod() != null) { | |
195 return getMethod().getSimpleName().toString(); | |
196 } else { | |
197 return "$synthetic"; | |
198 } | |
199 } | |
200 | |
201 public AnnotationMirror getMarkerAnnotation() { | |
202 return markerAnnotation; | |
203 } | |
204 | |
205 @Override | |
206 public String toString() { | |
207 return String.format("%s [id = %s, method = %s]", getClass().getSimpleName(), getId(), getMethod()); | |
208 } | |
209 | |
210 public Parameter getPreviousParam(Parameter searchParam) { | |
211 Parameter prev = null; | |
212 for (Parameter param : getParameters()) { | |
213 if (param == searchParam) { | |
214 return prev; | |
215 } | |
216 prev = param; | |
217 } | |
218 return prev; | |
219 } | |
220 | |
221 @SuppressWarnings("unused") | |
222 public int getSignatureSize() { | |
223 int signatureSize = 0; | |
224 for (Parameter parameter : getSignatureParameters()) { | |
225 signatureSize++; | |
226 } | |
227 return signatureSize; | |
228 } | |
229 | |
230 public TypeSignature getTypeSignature() { | |
231 TypeSignature signature = new TypeSignature(); | |
232 signature.types.add(getReturnType().getTypeSystemType()); | |
233 for (Parameter parameter : getSignatureParameters()) { | |
234 TypeData typeData = parameter.getTypeSystemType(); | |
235 if (typeData != null) { | |
236 signature.types.add(typeData); | |
237 } | |
238 } | |
239 return signature; | |
240 } | |
241 | |
242 public Parameter getSignatureParameter(int searchIndex) { | |
243 int index = 0; | |
244 for (Parameter parameter : getParameters()) { | |
245 if (!parameter.getSpecification().isSignature()) { | |
246 continue; | |
247 } | |
248 if (index == searchIndex) { | |
249 return parameter; | |
250 } | |
251 index++; | |
252 } | |
253 return null; | |
254 } | |
255 | |
256 public void updateSignature(TypeSignature signature) { | |
257 // TODO(CH): fails in normal usage - output ok though | |
258 // assert signature.size() >= 1; | |
259 | |
260 int signatureIndex = 0; | |
261 for (Parameter parameter : getReturnTypeAndParameters()) { | |
262 if (!parameter.getSpecification().isSignature()) { | |
263 continue; | |
264 } | |
265 if (signatureIndex >= signature.size()) { | |
266 break; | |
267 } | |
268 TypeData newType = signature.get(signatureIndex++); | |
269 if (!parameter.getTypeSystemType().equals(newType)) { | |
270 replaceParameter(parameter.getLocalName(), new Parameter(parameter, newType)); | |
271 } | |
272 } | |
273 } | |
274 | |
275 @Override | |
276 public int compareTo(TemplateMethod o) { | |
277 if (this == o) { | |
278 return 0; | |
279 } | |
280 | |
281 int compare = compareBySignature(o); | |
282 if (compare == 0) { | |
283 // if signature sorting failed sort by id | |
284 compare = getId().compareTo(o.getId()); | |
285 } | |
286 if (compare == 0) { | |
287 // if still no difference sort by enclosing type name | |
288 TypeElement enclosingType1 = ElementUtils.findNearestEnclosingType(getMethod()); | |
289 TypeElement enclosingType2 = ElementUtils.findNearestEnclosingType(o.getMethod()); | |
290 compare = enclosingType1.getQualifiedName().toString().compareTo(enclosingType2.getQualifiedName().toString()); | |
291 } | |
292 return compare; | |
293 } | |
294 | |
295 public List<Parameter> getParametersAfter(Parameter genericParameter) { | |
296 boolean found = false; | |
297 List<Parameter> foundParameters = new ArrayList<>(); | |
298 for (Parameter param : getParameters()) { | |
299 if (param.getLocalName().equals(genericParameter.getLocalName())) { | |
300 found = true; | |
301 } else if (found) { | |
302 foundParameters.add(param); | |
303 } | |
304 } | |
305 return foundParameters; | |
306 } | |
307 | |
308 public int compareBySignature(TemplateMethod compareMethod) { | |
309 final TypeSystemData typeSystem = getTemplate().getTypeSystem(); | |
310 if (typeSystem != compareMethod.getTemplate().getTypeSystem()) { | |
311 throw new IllegalStateException("Cannot compare two methods with different type systems."); | |
312 } | |
313 | |
314 List<TypeMirror> signature1 = getSignatureTypes(this); | |
315 List<TypeMirror> signature2 = getSignatureTypes(compareMethod); | |
316 | |
317 int result = 0; | |
318 for (int i = 0; i < Math.max(signature1.size(), signature2.size()); i++) { | |
319 TypeMirror t1 = i < signature1.size() ? signature1.get(i) : null; | |
320 TypeMirror t2 = i < signature2.size() ? signature2.get(i) : null; | |
321 result = compareParameter(typeSystem, t1, t2); | |
322 if (result != 0) { | |
323 break; | |
324 } | |
325 } | |
326 | |
327 return result; | |
328 } | |
329 | |
330 protected static int compareParameter(TypeSystemData data, TypeMirror signature1, TypeMirror signature2) { | |
331 if (signature1 == null) { | |
332 return 1; | |
333 } else if (signature2 == null) { | |
334 return -1; | |
335 } | |
336 | |
337 if (ElementUtils.typeEquals(signature1, signature2)) { | |
338 return 0; | |
339 } | |
340 | |
341 int index1 = data.findType(signature1); | |
342 int index2 = data.findType(signature2); | |
343 if (index1 != -1 && index2 != -1) { | |
344 return index1 - index2; | |
345 } | |
346 | |
347 // TODO this version if subclass of should be improved. | |
348 if (signature1.getKind() == TypeKind.DECLARED && signature2.getKind() == TypeKind.DECLARED) { | |
349 TypeElement element1 = ElementUtils.fromTypeMirror(signature1); | |
350 TypeElement element2 = ElementUtils.fromTypeMirror(signature2); | |
351 | |
352 if (ElementUtils.getDirectSuperTypes(element1).contains(element2)) { | |
353 return -1; | |
354 } else if (ElementUtils.getDirectSuperTypes(element2).contains(element1)) { | |
355 return 1; | |
356 } | |
357 } | |
358 return ElementUtils.getSimpleName(signature1).compareTo(ElementUtils.getSimpleName(signature2)); | |
359 } | |
360 | |
361 public static List<TypeMirror> getSignatureTypes(TemplateMethod method) { | |
362 List<TypeMirror> types = new ArrayList<>(); | |
363 for (Parameter param : method.getSignatureParameters()) { | |
364 types.add(param.getType()); | |
365 } | |
366 return types; | |
367 } | |
368 | |
369 public static class TypeSignature implements Iterable<TypeData>, Comparable<TypeSignature> { | |
370 | |
371 private final List<TypeData> types; | |
372 | |
373 public TypeSignature() { | |
374 this.types = new ArrayList<>(); | |
375 } | |
376 | |
377 public TypeSignature(List<TypeData> signature) { | |
378 this.types = signature; | |
379 } | |
380 | |
381 @Override | |
382 public int hashCode() { | |
383 return types.hashCode(); | |
384 } | |
385 | |
386 public int size() { | |
387 return types.size(); | |
388 } | |
389 | |
390 public TypeData get(int index) { | |
391 return types.get(index); | |
392 } | |
393 | |
394 public int compareTo(TypeSignature other) { | |
395 if (this == other) { | |
396 return 0; | |
397 } else if (types.size() != other.types.size()) { | |
398 return types.size() - other.types.size(); | |
399 } else if (types.isEmpty()) { | |
400 return 0; | |
401 } | |
402 | |
403 for (int i = 0; i < types.size(); i++) { | |
404 TypeData type1 = types.get(i); | |
405 TypeData type2 = other.types.get(i); | |
406 | |
407 int comparison = type1.compareTo(type2); | |
408 if (comparison != 0) { | |
409 return comparison; | |
410 } | |
411 } | |
412 | |
413 return 0; | |
414 } | |
415 | |
416 @Override | |
417 public boolean equals(Object obj) { | |
418 if (obj instanceof TypeSignature) { | |
419 return ((TypeSignature) obj).types.equals(types); | |
420 } | |
421 return super.equals(obj); | |
422 } | |
423 | |
424 public Iterator<TypeData> iterator() { | |
425 return types.iterator(); | |
426 } | |
427 | |
428 @Override | |
429 public String toString() { | |
430 return types.toString(); | |
431 } | |
432 } | |
433 | |
434 } |