Refactor TypeOracle to prevent external mutations.
This change makes it so that TypeOracle can only be modified through an associated TypeOracleBuilder. This prevents Generators from changing the TypeOracle data model.
http://gwt-code-reviews.appspot.com/748802/show
Review by: jat
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@8530 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/HasMetaData.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/HasMetaData.java
index f2b4ef2..83bcf0d 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/HasMetaData.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/HasMetaData.java
@@ -37,16 +37,6 @@
@Deprecated
public interface HasMetaData {
/**
- * Adds additional metadata.
- *
- * @deprecated Javadoc comment metadata has been deprecated in favor of proper
- * Java annotations. The only way to add a Java annotation is via
- * the source code.
- */
- @Deprecated
- void addMetaData(String tagName, String[] values);
-
- /**
* Gets each list of metadata for the specified tag name.
*
* @deprecated Javadoc comment metadata has been deprecated in favor of proper
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JAbstractMethod.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JAbstractMethod.java
index 2e46788..2e144a9 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JAbstractMethod.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JAbstractMethod.java
@@ -38,12 +38,12 @@
private List<JParameter> params = Lists.create();
+ private String[] realParameterNames = null;
+
private List<JType> thrownTypes = Lists.create();
private List<JTypeParameter> typeParams = Lists.create();
- private String[] realParameterNames = null;
-
JAbstractMethod(JAbstractMethod srcMethod) {
this.annotations = new Annotations(srcMethod.annotations);
this.isVarArgs = srcMethod.isVarArgs;
@@ -63,19 +63,6 @@
}
}
- @Deprecated
- public final void addMetaData(String tagName, String[] values) {
- throw new UnsupportedOperationException();
- }
-
- public void addModifierBits(int bits) {
- modifierBits |= bits;
- }
-
- public void addThrows(JType type) {
- thrownTypes = Lists.add(thrownTypes, type);
- }
-
public JParameter findParameter(String name) {
for (JParameter param : params) {
if (param.getName().equals(name)) {
@@ -162,10 +149,6 @@
return isVarArgs;
}
- public void setVarArgs() {
- isVarArgs = true;
- }
-
protected int getModifierBits() {
return modifierBits;
}
@@ -221,10 +204,18 @@
sb.append(">");
}
+ void addModifierBits(int bits) {
+ modifierBits |= bits;
+ }
+
void addParameter(JParameter param) {
params = Lists.add(params, param);
}
+ void addThrows(JType type) {
+ thrownTypes = Lists.add(thrownTypes, type);
+ }
+
/**
* NOTE: This method is for testing purposes only.
*/
@@ -271,6 +262,10 @@
return true;
}
+ void setVarArgs() {
+ isVarArgs = true;
+ }
+
private void fetchRealParameterNames() {
realParameterNames = getEnclosingType().getOracle().getJavaSourceParser().getArguments(this);
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationMethod.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationMethod.java
index 4896191..f1af6a8 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationMethod.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationMethod.java
@@ -23,15 +23,15 @@
*/
public class JAnnotationMethod extends JMethod {
/**
- * Default value for this annotation element. <code>null</code> is not a
- * valid default value for an annotation element.
+ * Default value for this annotation element. <code>null</code> is not a valid
+ * default value for an annotation element.
*/
private final Object defaultValue;
- public JAnnotationMethod(JClassType enclosingType, String name,
- Object defaultValue,
- Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
- super(enclosingType, name, declaredAnnotations, null);
+ JAnnotationMethod(JClassType enclosingType, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] jtypeParameters, Object defaultValue) {
+ super(enclosingType, name, declaredAnnotations, jtypeParameters);
this.defaultValue = defaultValue;
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationType.java
index 2063d58..9f7f69d 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JAnnotationType.java
@@ -22,11 +22,10 @@
*/
public class JAnnotationType extends JRealClassType {
- public JAnnotationType(TypeOracle oracle, JPackage declaringPackage,
- String enclosingTypeName, boolean isLocalType, String name,
- boolean isInterface) {
- super(oracle, declaringPackage, enclosingTypeName, isLocalType, name,
- isInterface);
+ JAnnotationType(TypeOracle oracle, JPackage declaringPackage,
+ String enclosingTypeName, String name) {
+ super(oracle, declaringPackage, enclosingTypeName, false, name,
+ true);
}
@Override
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JArrayType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JArrayType.java
index aca74a7..d9d73e8 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JArrayType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JArrayType.java
@@ -40,18 +40,6 @@
}
@Override
- public void addImplementedInterface(JClassType intf) {
- throw new UnsupportedOperationException("modifying a "
- + getClass().getSimpleName());
- }
-
- @Override
- public void addModifierBits(int bits) {
- throw new UnsupportedOperationException("modifying a "
- + getClass().getSimpleName());
- }
-
- @Override
public JConstructor findConstructor(JType[] paramTypes) {
return null;
}
@@ -191,7 +179,7 @@
}
return lazyQualifiedBinaryName;
}
-
+
@Override
public String getQualifiedSourceName() {
if (lazyQualifiedName == null) {
@@ -338,19 +326,6 @@
return null;
}
- public void setLeafType(JType type) {
- JArrayType componentTypeIsArray = componentType.isArray();
- if (componentTypeIsArray != null) {
- componentTypeIsArray.setLeafType(type);
- } else {
- componentType = type;
- }
- }
-
- @Override
- public void setSuperclass(JClassType type) {
- }
-
@Override
public String toString() {
return getQualifiedSourceName();
@@ -402,12 +377,24 @@
}
@Override
+ void addImplementedInterface(JClassType intf) {
+ throw new UnsupportedOperationException("modifying a "
+ + getClass().getSimpleName());
+ }
+
+ @Override
void addMethod(JMethod method) {
throw new UnsupportedOperationException("modifying a "
+ getClass().getSimpleName());
}
@Override
+ void addModifierBits(int bits) {
+ throw new UnsupportedOperationException("modifying a "
+ + getClass().getSimpleName());
+ }
+
+ @Override
void addNestedType(JClassType type) {
throw new UnsupportedOperationException("modifying a "
+ getClass().getSimpleName());
@@ -447,4 +434,17 @@
@Override
void removeFromSupertypes() {
}
+
+ void setLeafType(JType type) {
+ JArrayType componentTypeIsArray = componentType.isArray();
+ if (componentTypeIsArray != null) {
+ componentTypeIsArray.setLeafType(type);
+ } else {
+ componentType = type;
+ }
+ }
+
+ @Override
+ void setSuperclass(JClassType type) {
+ }
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java
index 50468df..67b39b2 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JClassType.java
@@ -324,7 +324,7 @@
for (JClassType intf : intfs) {
typesSeen.addAll(getFlattenedSuperTypeHierarchy(intf));
}
-
+
// Superclass
JClassType superclass = type.getSuperclass();
if (superclass != null) {
@@ -337,24 +337,15 @@
* has not been calculated yet.
*/
private Set<JClassType> flattenedSupertypes;
-
+
/**
- * True if this type may be enhanced with server-only fields. This property
- * is 'sticky' and may be set but not unset, since we need to generate the
- * relevant RPC code for handling the server fields if there is any chance
- * the class will be enhanced.
+ * True if this type may be enhanced with server-only fields. This property is
+ * 'sticky' and may be set but not unset, since we need to generate the
+ * relevant RPC code for handling the server fields if there is any chance the
+ * class will be enhanced.
*/
private boolean isEnhanced = false;
- public abstract void addImplementedInterface(JClassType intf);
-
- @Deprecated
- public final void addMetaData(String tagName, String[] values) {
- throw new UnsupportedOperationException();
- }
-
- public abstract void addModifierBits(int bits);
-
public JParameterizedType asParameterizationOf(JGenericType type) {
Set<JClassType> supertypes = getFlattenedSuperTypeHierarchy(this);
for (JClassType supertype : supertypes) {
@@ -580,10 +571,10 @@
* <code>false</code> otherwise
*/
public abstract boolean isDefaultInstantiable();
-
+
/**
- * Returns true if the type may be enhanced on the server to contain
- * extra fields that are unknown to client code.
+ * Returns true if the type may be enhanced on the server to contain extra
+ * fields that are unknown to client code.
*
* @return <code>true</code> if the type might be enhanced on the server
*/
@@ -622,17 +613,17 @@
public abstract boolean isPublic();
public abstract boolean isStatic();
-
+
/**
- * Indicates that the type may be enhanced on the server to contain
- * extra fields that are unknown to client code.
+ * Indicates that the type may be enhanced on the server to contain extra
+ * fields that are unknown to client code.
+ *
+ * TODO(rice): find a better way to do this.
*/
public void setEnhanced() {
this.isEnhanced = true;
}
- public abstract void setSuperclass(JClassType type);
-
@Override
public String toString() {
return this.getQualifiedSourceName();
@@ -671,8 +662,12 @@
abstract void addField(JField field);
+ abstract void addImplementedInterface(JClassType intf);
+
abstract void addMethod(JMethod method);
+ abstract void addModifierBits(int bits);
+
abstract void addNestedType(JClassType type);
abstract JClassType findNestedTypeImpl(String[] typeName, int index);
@@ -700,4 +695,6 @@
* Removes references to this instance from all of its super types.
*/
abstract void removeFromSupertypes();
+
+ abstract void setSuperclass(JClassType type);
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JConstructor.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JConstructor.java
index 714aca2..e1ad060 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JConstructor.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JConstructor.java
@@ -24,11 +24,16 @@
public class JConstructor extends JAbstractMethod {
private final JClassType enclosingType;
- public JConstructor(JClassType enclosingType, String name) {
+ JConstructor(JClassType enclosingType, JConstructor ctor) {
+ super(ctor);
+ this.enclosingType = enclosingType;
+ }
+
+ JConstructor(JClassType enclosingType, String name) {
this(enclosingType, name, null, null);
}
- public JConstructor(JClassType enclosingType, String name,
+ JConstructor(JClassType enclosingType, String name,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
JTypeParameter[] jtypeParameters) {
super(name, declaredAnnotations, jtypeParameters);
@@ -37,11 +42,6 @@
enclosingType.addConstructor(this);
}
- JConstructor(JClassType enclosingType, JConstructor ctor) {
- super(ctor);
- this.enclosingType = enclosingType;
- }
-
@Override
public JClassType getEnclosingType() {
return enclosingType;
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumConstant.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumConstant.java
index cf35f88..d03974d 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumConstant.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumConstant.java
@@ -24,7 +24,7 @@
public class JEnumConstant extends JField {
private final int ordinal;
- public JEnumConstant(JClassType enclosingType, String name,
+ JEnumConstant(JClassType enclosingType, String name,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
int ordinal) {
super(enclosingType, name, declaredAnnotations);
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumType.java
index 347b534..d2ce0c2 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JEnumType.java
@@ -24,11 +24,10 @@
public class JEnumType extends JRealClassType {
private JEnumConstant[] lazyEnumConstants;
- public JEnumType(TypeOracle oracle, JPackage declaringPackage,
- String enclosingTypeName, boolean isLocalType, String name,
- boolean isInterface) {
+ JEnumType(TypeOracle oracle, JPackage declaringPackage,
+ String enclosingTypeName, boolean isLocalType, String name) {
super(oracle, declaringPackage, enclosingTypeName, isLocalType, name,
- isInterface);
+ false);
}
/**
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JField.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JField.java
index 6d44e73..ea912fb 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JField.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JField.java
@@ -34,19 +34,6 @@
private JType type;
- public JField(JClassType enclosingType, String name) {
- this(enclosingType, name, null);
- }
-
- public JField(JClassType enclosingType, String name,
- Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
- assert (enclosingType != null);
- this.enclosingType = enclosingType;
- this.name = name;
- this.enclosingType.addField(this);
- annotations = new Annotations(declaredAnnotations);
- }
-
JField(JClassType enclosingType, JField srcField) {
this.annotations = new Annotations(srcField.annotations);
this.enclosingType = enclosingType;
@@ -55,13 +42,17 @@
this.type = srcField.type;
}
- @Deprecated
- public final void addMetaData(String tagName, String[] values) {
- throw new UnsupportedOperationException();
+ JField(JClassType enclosingType, String name) {
+ this(enclosingType, name, null);
}
- public void addModifierBits(int modifierBits) {
- this.modifierBits |= modifierBits;
+ JField(JClassType enclosingType, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ assert (enclosingType != null);
+ this.enclosingType = enclosingType;
+ this.name = name;
+ this.enclosingType.addField(this);
+ annotations = new Annotations(declaredAnnotations);
}
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
@@ -132,10 +123,6 @@
return 0 != (modifierBits & TypeOracle.MOD_VOLATILE);
}
- public void setType(JType type) {
- this.type = type;
- }
-
@Override
public String toString() {
String[] names = TypeOracle.modifierBitsToNames(modifierBits);
@@ -155,6 +142,10 @@
return sb.toString();
}
+ void addModifierBits(int modifierBits) {
+ this.modifierBits |= modifierBits;
+ }
+
/**
* NOTE: This method is for testing purposes only.
*/
@@ -168,4 +159,8 @@
Annotation[] getDeclaredAnnotations() {
return annotations.getDeclaredAnnotations();
}
+
+ void setType(JType type) {
+ this.type = type;
+ }
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JGenericMethod.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JGenericMethod.java
deleted file mode 100644
index 9d7956f..0000000
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JGenericMethod.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright 2007 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.core.ext.typeinfo;
-
-/**
- *
- */
-public class JGenericMethod {
-
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JMethod.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JMethod.java
index 387fd74..da1c478 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JMethod.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JMethod.java
@@ -27,11 +27,17 @@
private JType returnType;
- public JMethod(JClassType enclosingType, String name) {
+ JMethod(JClassType enclosingType, JMethod srcMethod) {
+ super(srcMethod);
+ this.enclosingType = enclosingType;
+ this.returnType = srcMethod.returnType;
+ }
+
+ JMethod(JClassType enclosingType, String name) {
this(enclosingType, name, null, null);
}
- public JMethod(JClassType enclosingType, String name,
+ JMethod(JClassType enclosingType, String name,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
JTypeParameter[] jtypeParameters) {
super(name, declaredAnnotations, jtypeParameters);
@@ -39,12 +45,6 @@
enclosingType.addMethod(this);
}
- JMethod(JClassType enclosingType, JMethod srcMethod) {
- super(srcMethod);
- this.enclosingType = enclosingType;
- this.returnType = srcMethod.returnType;
- }
-
@Override
public JClassType getEnclosingType() {
return enclosingType;
@@ -120,10 +120,6 @@
return 0 != (getModifierBits() & TypeOracle.MOD_STATIC);
}
- public void setReturnType(JType type) {
- returnType = type;
- }
-
@Override
public String toString() {
return getReadableDeclaration();
@@ -148,4 +144,8 @@
return sb.toString();
}
+
+ void setReturnType(JType type) {
+ returnType = type;
+ }
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JPackage.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JPackage.java
index fbe40da..b56e227 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JPackage.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JPackage.java
@@ -35,7 +35,7 @@
this.name = name;
}
- public void addAnnotations(
+ void addAnnotations(
Map<Class<? extends Annotation>, Annotation> annotations) {
this.annotations.addAnnotations(annotations);
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameter.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameter.java
index df15ce1..f7b0686 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameter.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameter.java
@@ -26,25 +26,32 @@
private final Annotations annotations;
- private String name;
-
- private JType type;
+ private boolean argNameIsReal;
private final JAbstractMethod enclosingMethod;
- private boolean argNameIsReal;
+ private String name;
+
+ private JType type;
- public JParameter(JAbstractMethod enclosingMethod, JType type,
+ JParameter(JAbstractMethod enclosingMethod, JParameter srcParam) {
+ this.enclosingMethod = enclosingMethod;
+ this.type = srcParam.type;
+ this.name = srcParam.name;
+ this.annotations = new Annotations(srcParam.annotations);
+ }
+
+ JParameter(JAbstractMethod enclosingMethod, JType type,
String name) {
this(enclosingMethod, type, name, null);
}
- public JParameter(JAbstractMethod enclosingMethod, JType type, String name,
+ JParameter(JAbstractMethod enclosingMethod, JType type, String name,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
this(enclosingMethod, type, name, declaredAnnotations, true);
}
- public JParameter(JAbstractMethod enclosingMethod, JType type, String name,
+ JParameter(JAbstractMethod enclosingMethod, JType type, String name,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
boolean argNameIsReal) {
this.enclosingMethod = enclosingMethod;
@@ -57,18 +64,6 @@
annotations = new Annotations(declaredAnnotations);
}
- JParameter(JAbstractMethod enclosingMethod, JParameter srcParam) {
- this.enclosingMethod = enclosingMethod;
- this.type = srcParam.type;
- this.name = srcParam.name;
- this.annotations = new Annotations(srcParam.annotations);
- }
-
- @Deprecated
- public final void addMetaData(String tagName, String[] values) {
- throw new UnsupportedOperationException();
- }
-
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
return annotations.getAnnotation(annotationClass);
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedMethod.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedMethod.java
deleted file mode 100644
index c161df2..0000000
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedMethod.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright 2007 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
-package com.google.gwt.core.ext.typeinfo;
-
-/**
- *
- */
-public class JParameterizedMethod {
-
-}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java
index 1eaf518..fe8af67 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JParameterizedType.java
@@ -71,19 +71,19 @@
private List<JClassType> interfaces;
- private JClassType lazySuperclass;
-
- private final AbstractMembers members;
-
- private final List<JClassType> typeArgs;
-
/**
* This map records the JClassType that should be used in place of a given
* {@link JTypeParameter}.
*/
private Map<JTypeParameter, JClassType> lazySubstitutionMap;
- public JParameterizedType(JGenericType baseType, JClassType enclosingType,
+ private JClassType lazySuperclass;
+
+ private final AbstractMembers members;
+
+ private final List<JClassType> typeArgs;
+
+ JParameterizedType(JGenericType baseType, JClassType enclosingType,
JClassType[] typeArgs) {
super.setBaseType(baseType);
@@ -341,12 +341,6 @@
return null;
}
- /**
- */
- public void setTypeArguments(JClassType[] typeArgs) {
- this.typeArgs.addAll(Arrays.asList(typeArgs));
- }
-
@Override
public String toString() {
if (isInterface() != null) {
@@ -468,6 +462,10 @@
lazySubstitutionMap = Maps.normalize(lazySubstitutionMap);
}
+ void setTypeArguments(JClassType[] typeArgs) {
+ this.typeArgs.addAll(Arrays.asList(typeArgs));
+ }
+
/**
* Returns a map of substitutions that will make the subtype a proper subtype
* of this parameterized type. The map maybe empty in the case that it is
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRawType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRawType.java
index b0d40ac..263b46d 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRawType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRawType.java
@@ -32,7 +32,7 @@
private final AbstractMembers members;
- public JRawType(JGenericType genericType) {
+ JRawType(JGenericType genericType) {
super.setBaseType(genericType);
members = new DelegateMembers(this, getBaseType(), ERASURE_SUBSTITUTION);
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
index 560fe0c..9ec15c9 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JRealClassType.java
@@ -73,7 +73,7 @@
* @param name
* @param isInterface
*/
- public JRealClassType(TypeOracle oracle, JPackage declaringPackage,
+ JRealClassType(TypeOracle oracle, JPackage declaringPackage,
String enclosingTypeName, boolean isLocalType, String name,
boolean isInterface) {
this.oracle = oracle;
@@ -99,17 +99,6 @@
oracle.addNewType(this);
}
- public void addAnnotations(
- Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
- annotations.addAnnotations(declaredAnnotations);
- }
-
- @Override
- public void addImplementedInterface(JClassType intf) {
- assert (intf != null);
- interfaces = Lists.add(interfaces, intf);
- }
-
@Override
public void addModifierBits(int bits) {
modifierBits |= bits;
@@ -412,45 +401,6 @@
return null;
}
- /**
- * INTERNAL METHOD -- this should only be called by TypeOracleMediator.
- *
- * TODO: reduce visibility.
- *
- * @param enclosingType
- */
- public void setEnclosingType(JClassType enclosingType) {
- assert this.enclosingType == null;
- assert enclosingType != null;
-
- this.enclosingType = enclosingType;
-
- // Add myself to my enclosing type.
- JRawType rawType = enclosingType.isRawType();
- if (rawType != null) {
- enclosingType = rawType.getGenericType();
- }
- enclosingType.addNestedType(this);
- }
-
- @Override
- public void setSuperclass(JClassType type) {
- assert (type != null);
- assert (isInterface() == null);
- this.superclass = type;
- JRealClassType realSuperType;
- if (type.isParameterized() != null) {
- realSuperType = type.isParameterized().getBaseType();
- } else if (type.isRawType() != null) {
- realSuperType = type.isRawType().getGenericType();
- } else if (type instanceof JRealClassType) {
- realSuperType = (JRealClassType) type;
- } else {
- throw new IllegalArgumentException("Unknown type for " + type);
- }
- annotations.setParent(realSuperType.annotations);
- }
-
@Override
public String toString() {
if (isInterface) {
@@ -546,6 +496,17 @@
}
}
+ void addAnnotations(
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ annotations.addAnnotations(declaredAnnotations);
+ }
+
+ @Override
+ void addImplementedInterface(JClassType intf) {
+ assert (intf != null);
+ interfaces = Lists.add(interfaces, intf);
+ }
+
/**
* NOTE: This method is for testing purposes only.
*/
@@ -579,4 +540,36 @@
void removeFromSupertypes() {
removeSubtype(this);
}
+
+ void setEnclosingType(JClassType enclosingType) {
+ assert this.enclosingType == null;
+ assert enclosingType != null;
+
+ this.enclosingType = enclosingType;
+
+ // Add myself to my enclosing type.
+ JRawType rawType = enclosingType.isRawType();
+ if (rawType != null) {
+ enclosingType = rawType.getGenericType();
+ }
+ enclosingType.addNestedType(this);
+ }
+
+ @Override
+ void setSuperclass(JClassType type) {
+ assert (type != null);
+ assert (isInterface() == null);
+ this.superclass = type;
+ JRealClassType realSuperType;
+ if (type.isParameterized() != null) {
+ realSuperType = type.isParameterized().getBaseType();
+ } else if (type.isRawType() != null) {
+ realSuperType = type.isRawType().getGenericType();
+ } else if (type instanceof JRealClassType) {
+ realSuperType = (JRealClassType) type;
+ } else {
+ throw new IllegalArgumentException("Unknown type for " + type);
+ }
+ annotations.setParent(realSuperType.annotations);
+ }
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JType.java
index 6c4a34f..36d7e95 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JType.java
@@ -20,6 +20,9 @@
*/
public abstract class JType {
+ JType() {
+ }
+
/**
* All types use identity for comparison.
*/
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java
index 859fde1..4eaf4b8 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/JWildcardType.java
@@ -43,7 +43,7 @@
private JClassType[] lazyLowerBounds;
private JClassType[] lazyUpperBounds;
- public JWildcardType(BoundType boundType, JClassType typeBound) {
+ JWildcardType(BoundType boundType, JClassType typeBound) {
this.boundType = boundType;
super.setBaseType(typeBound);
}
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
index 8521d4a..e584743 100644
--- a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracle.java
@@ -298,17 +298,6 @@
}
/**
- * Called to add a source reference for a top-level class type.
- *
- * SHOULD ONLY BE CALLED FROM TypeOracleMediator.
- *
- * TODO: make not public?
- */
- public void addSourceReference(JRealClassType type, Resource sourceFile) {
- javaSourceParser.addSourceForType(type, sourceFile);
- }
-
- /**
* Attempts to find a package by name. All requests for the same package
* return the same package object.
*
@@ -352,18 +341,6 @@
}
/**
- * Called after a block of new types are added.
- *
- * TODO: make not public?
- */
- public void finish() {
- JClassType[] newTypes = recentTypes.toArray(new JClassType[recentTypes.size()]);
- computeHierarchyRelationships(newTypes);
- computeSingleJsoImplData(newTypes);
- recentTypes.clear();
- }
-
- /**
* Gets the type object that represents an array of the specified type. The
* returned type always has a stable identity so as to guarantee that all
* calls to this method with the same argument return the same object.
@@ -393,10 +370,6 @@
return javaLangObject;
}
- public JavaSourceParser getJavaSourceParser() {
- return javaSourceParser;
- }
-
/**
* Ensure that a package with the specified name exists as well as its parent
* packages.
@@ -654,6 +627,27 @@
recentTypes.add(newType);
}
+ /**
+ * Called to add a source reference for a top-level class type.
+ */
+ void addSourceReference(JRealClassType type, Resource sourceFile) {
+ javaSourceParser.addSourceForType(type, sourceFile);
+ }
+
+ /**
+ * Called after a block of new types are added.
+ */
+ void finish() {
+ JClassType[] newTypes = recentTypes.toArray(new JClassType[recentTypes.size()]);
+ computeHierarchyRelationships(newTypes);
+ computeSingleJsoImplData(newTypes);
+ recentTypes.clear();
+ }
+
+ JavaSourceParser getJavaSourceParser() {
+ return javaSourceParser;
+ }
+
private void computeHierarchyRelationships(JClassType[] types) {
// For each type, walk up its hierarchy chain and tell each supertype
// about its subtype.
diff --git a/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracleBuilder.java b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracleBuilder.java
new file mode 100644
index 0000000..191ecb5
--- /dev/null
+++ b/dev/core/src/com/google/gwt/core/ext/typeinfo/TypeOracleBuilder.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.core.ext.typeinfo;
+
+import java.lang.annotation.Annotation;
+import java.util.Map;
+
+/**
+ * Constructs a new {@link TypeOracle}. This class provides package-level access
+ * to a TypeOracle that is under construction. Once the TypeOracle is built, new
+ * classes can be added later, but should never be removed.
+ *
+ * This class's API is an implementation detail and should not be considered
+ * stable. It is subject to change.
+ */
+public class TypeOracleBuilder {
+ /**
+ * The TypeOracle being built.
+ */
+ protected final TypeOracle typeOracle = new TypeOracle();
+
+ protected void addAnnotations(JPackage pkg,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ pkg.addAnnotations(declaredAnnotations);
+ }
+
+ protected void addAnnotations(JRealClassType type,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ type.addAnnotations(declaredAnnotations);
+ }
+
+ protected void addImplementedInterface(JRealClassType type, JClassType intf) {
+ type.addImplementedInterface(intf);
+ }
+
+ protected void addModifierBits(JAbstractMethod method, int modifierBits) {
+ method.addModifierBits(modifierBits);
+ }
+
+ protected void addModifierBits(JField jfield, int modifierBits) {
+ jfield.addModifierBits(modifierBits);
+ }
+
+ protected void addThrows(JAbstractMethod method, JType exception) {
+ method.addThrows(exception);
+ }
+
+ protected void finish() {
+ typeOracle.finish();
+ }
+
+ protected JAnnotationMethod newAnnotationMethod(JRealClassType enclosingType,
+ String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] jtypeParameters, Object defaultValue) {
+ return new JAnnotationMethod(enclosingType, name, declaredAnnotations,
+ jtypeParameters, defaultValue);
+ }
+
+ protected JAnnotationType newAnnotationType(JPackage pkg,
+ String enclosingTypeName, String className) {
+ return new JAnnotationType(typeOracle, pkg, enclosingTypeName, className);
+ }
+
+ protected JConstructor newConstructor(JRealClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] typeParams) {
+ return new JConstructor(type, name, declaredAnnotations, typeParams);
+ }
+
+ protected JEnumConstant newEnumConstant(JRealClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ int ordinal) {
+ return new JEnumConstant(type, name, declaredAnnotations, ordinal);
+ }
+
+ protected JEnumType newEnumType(JPackage pkg, String enclosingTypeName,
+ boolean isLocalType, String className) {
+ return new JEnumType(typeOracle, pkg, enclosingTypeName, isLocalType,
+ className);
+ }
+
+ protected JField newField(JRealClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ return new JField(type, name, declaredAnnotations);
+ }
+
+ protected JMethod newMethod(JClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] typeParams) {
+ return new JMethod(type, name, declaredAnnotations, typeParams);
+ }
+
+ protected void newParameter(JAbstractMethod method, JType argType,
+ String argName,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ boolean argNamesAreReal) {
+ new JParameter(method, argType, argName, declaredAnnotations,
+ argNamesAreReal);
+ }
+
+ protected JRealClassType newRealClassType(JPackage pkg,
+ String enclosingTypeName, boolean isLocalType, String className,
+ boolean isIntf) {
+ return new JRealClassType(typeOracle, pkg, enclosingTypeName, isLocalType,
+ className, isIntf);
+ }
+
+ protected void setEnclosingType(JRealClassType type, JClassType enclosingType) {
+ type.setEnclosingType(enclosingType);
+ }
+
+ protected void setFieldType(JField jfield, JType fieldType) {
+ jfield.setType(fieldType);
+ }
+
+ protected void setReturnType(JAbstractMethod method, JType returnType) {
+ ((JMethod) method).setReturnType(returnType);
+ }
+
+ protected void setSuperClass(JRealClassType type, JClassType superType) {
+ type.setSuperclass(superType);
+ }
+
+ protected void setVarArgs(JAbstractMethod method) {
+ method.setVarArgs();
+ }
+
+}
diff --git a/dev/core/src/com/google/gwt/dev/javac/CompilationState.java b/dev/core/src/com/google/gwt/dev/javac/CompilationState.java
index c224fc3..0d7c024 100644
--- a/dev/core/src/com/google/gwt/dev/javac/CompilationState.java
+++ b/dev/core/src/com/google/gwt/dev/javac/CompilationState.java
@@ -132,6 +132,13 @@
return mediator.getTypeOracle();
}
+ /**
+ * For testing.
+ */
+ TypeOracleMediator getMediator() {
+ return mediator;
+ }
+
private void assimilateUnits(TreeLogger logger,
Collection<CompilationUnit> units) {
for (CompilationUnit unit : units) {
diff --git a/dev/core/src/com/google/gwt/dev/javac/Resolver.java b/dev/core/src/com/google/gwt/dev/javac/Resolver.java
index e62b129..c1ebe77 100644
--- a/dev/core/src/com/google/gwt/dev/javac/Resolver.java
+++ b/dev/core/src/com/google/gwt/dev/javac/Resolver.java
@@ -16,7 +16,13 @@
package com.google.gwt.dev.javac;
import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JPackage;
import com.google.gwt.core.ext.typeinfo.JRealClassType;
+import com.google.gwt.core.ext.typeinfo.JType;
+import com.google.gwt.core.ext.typeinfo.JTypeParameter;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.dev.javac.asm.CollectAnnotationData;
@@ -29,10 +35,25 @@
*/
public interface Resolver {
+ void addImplementedInterface(JRealClassType type, JClassType intf);
+
+ void addThrows(JAbstractMethod method, JType exception);
+
Map<String, JRealClassType> getBinaryMapper();
TypeOracle getTypeOracle();
+ JMethod newMethod(JClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] typeParams);
+
+ void newParameter(JAbstractMethod method, JType argType, String argName,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ boolean argNamesAreReal);
+
+ JRealClassType newRealClassType(JPackage pkg, String enclosingTypeName,
+ boolean isLocalType, String className, boolean isIntf);
+
boolean resolveAnnotation(TreeLogger logger,
CollectAnnotationData annotVisitor,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations);
@@ -42,4 +63,8 @@
Map<Class<? extends Annotation>, Annotation> declaredAnnotations);
boolean resolveClass(TreeLogger logger, JRealClassType type);
+
+ void setReturnType(JAbstractMethod method, JType returnType);
+
+ void setSuperClass(JRealClassType type, JClassType superType);
}
diff --git a/dev/core/src/com/google/gwt/dev/javac/TypeOracleMediator.java b/dev/core/src/com/google/gwt/dev/javac/TypeOracleMediator.java
index b197ea2..44c44b6 100644
--- a/dev/core/src/com/google/gwt/dev/javac/TypeOracleMediator.java
+++ b/dev/core/src/com/google/gwt/dev/javac/TypeOracleMediator.java
@@ -1,12 +1,12 @@
/*
* Copyright 2008 Google Inc.
- *
+ *
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
@@ -17,18 +17,12 @@
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
-import com.google.gwt.core.ext.typeinfo.JAnnotationMethod;
-import com.google.gwt.core.ext.typeinfo.JAnnotationType;
import com.google.gwt.core.ext.typeinfo.JArrayType;
import com.google.gwt.core.ext.typeinfo.JClassType;
-import com.google.gwt.core.ext.typeinfo.JConstructor;
-import com.google.gwt.core.ext.typeinfo.JEnumConstant;
-import com.google.gwt.core.ext.typeinfo.JEnumType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JGenericType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JPackage;
-import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JRawType;
@@ -37,6 +31,7 @@
import com.google.gwt.core.ext.typeinfo.JTypeParameter;
import com.google.gwt.core.ext.typeinfo.JWildcardType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.core.ext.typeinfo.TypeOracleBuilder;
import com.google.gwt.dev.asm.ClassReader;
import com.google.gwt.dev.asm.ClassVisitor;
import com.google.gwt.dev.asm.Opcodes;
@@ -76,7 +71,7 @@
* Builds or rebuilds a {@link com.google.gwt.core.ext.typeinfo.TypeOracle} from
* a set of compilation units.
*/
-public class TypeOracleMediator {
+public class TypeOracleMediator extends TypeOracleBuilder {
/**
* Turn on to trace class processing.
@@ -86,7 +81,7 @@
/**
* Pairs of bits to convert from ASM Opcodes.* to Shared.* bitfields.
*/
- private static final int[] ASM_TO_SHARED_MODIFIERS = new int[] {
+ private static final int[] ASM_TO_SHARED_MODIFIERS = new int[]{
Opcodes.ACC_PUBLIC, Shared.MOD_PUBLIC, Opcodes.ACC_PRIVATE,
Shared.MOD_PRIVATE, Opcodes.ACC_PROTECTED, Shared.MOD_PROTECTED,
Opcodes.ACC_STATIC, Shared.MOD_STATIC, Opcodes.ACC_FINAL,
@@ -99,7 +94,7 @@
/**
* Returns the binary name of a type. This is the same name that would be
* returned by {@link Class#getName()} for this type.
- *
+ *
* @param type TypeOracle type to get the name for
* @return binary name for a type
*/
@@ -192,9 +187,9 @@
/**
* Returns true if this class is a non-static class inside a generic class.
- *
+ *
* TODO(jat): do we need to consider the entire hierarchy?
- *
+ *
* @param classData
* @param enclosingClassData
* @return true if this class is a non-static class inside a generic class
@@ -210,7 +205,7 @@
/**
* Substitute the raw type if the supplied type is generic.
- *
+ *
* @param type
* @return original type or its raw type if it is generic
*/
@@ -227,8 +222,6 @@
// map of internal names to classes
final Map<String, JRealClassType> binaryMapper = new HashMap<String, JRealClassType>();
- final TypeOracle typeOracle;
-
// map of fully qualified method names to their argument names
// transient since it is not retained across calls to addNewUnits
private transient MethodArgNamesLookup allMethodArgs;
@@ -248,29 +241,49 @@
* Construct a TypeOracleMediator.
*/
public TypeOracleMediator() {
- this(null);
- }
-
- /**
- * Construct a TypeOracleMediator.
- *
- * @param typeOracle TypeOracle instance to use, or null to create a new one
- */
- // @VisibleForTesting
- public TypeOracleMediator(TypeOracle typeOracle) {
- if (typeOracle == null) {
- typeOracle = new TypeOracle();
- }
- this.typeOracle = typeOracle;
resolver = new Resolver() {
+ public void addImplementedInterface(JRealClassType type, JClassType intf) {
+ TypeOracleMediator.this.addImplementedInterface(type, intf);
+ }
+
+ public void addThrows(JAbstractMethod method, JType exception) {
+ TypeOracleMediator.this.addThrows(method, exception);
+ }
+
public Map<String, JRealClassType> getBinaryMapper() {
return TypeOracleMediator.this.binaryMapper;
}
+ public TypeOracleMediator getMediator() {
+ return TypeOracleMediator.this;
+ }
+
public TypeOracle getTypeOracle() {
return TypeOracleMediator.this.typeOracle;
}
+ public JMethod newMethod(JClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] typeParams) {
+ return TypeOracleMediator.this.newMethod(type, name,
+ declaredAnnotations, typeParams);
+ }
+
+ public void newParameter(JAbstractMethod method, JType argType,
+ String argName,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ boolean argNamesAreReal) {
+ TypeOracleMediator.this.newParameter(method, argType, argName,
+ declaredAnnotations, argNamesAreReal);
+ }
+
+ public JRealClassType newRealClassType(JPackage pkg,
+ String enclosingTypeName, boolean isLocalType, String className,
+ boolean isIntf) {
+ return TypeOracleMediator.this.newRealClassType(pkg, enclosingTypeName,
+ isLocalType, className, isIntf);
+ }
+
public boolean resolveAnnotation(TreeLogger logger,
CollectAnnotationData annotVisitor,
Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
@@ -288,12 +301,20 @@
public boolean resolveClass(TreeLogger logger, JRealClassType type) {
return TypeOracleMediator.this.resolveClass(logger, type);
}
+
+ public void setReturnType(JAbstractMethod method, JType returnType) {
+ TypeOracleMediator.this.setReturnType(method, returnType);
+ }
+
+ public void setSuperClass(JRealClassType type, JClassType superType) {
+ TypeOracleMediator.this.setSuperClass(type, superType);
+ }
};
}
/**
* Adds new units to an existing TypeOracle.
- *
+ *
* @param logger logger to use
* @param units collection of compilation units to process
*/
@@ -369,7 +390,7 @@
resolveUnresolvedEvent.end();
Event finishEvent = SpeedTracerLogger.start(CompilerEventType.TYPE_ORACLE_MEDIATOR, "phase", "Finish");
- typeOracle.finish();
+ super.finish();
finishEvent.end();
// no longer needed
@@ -387,6 +408,13 @@
}
/**
+ * @return this mediator's resolver.
+ */
+ public Resolver getResolver() {
+ return resolver;
+ }
+
+ /**
* @return the TypeOracle managed by the mediator.
*/
public TypeOracle getTypeOracle() {
@@ -432,11 +460,9 @@
enclosingTypeName = InternalName.toSourceName(InternalName.getClassName(enclosingClassData.getName()));
}
if ((access & Opcodes.ACC_ANNOTATION) != 0) {
- resultType = new JAnnotationType(typeOracle, pkg, enclosingTypeName,
- false, className, true);
+ resultType = newAnnotationType(pkg, enclosingTypeName, className);
} else if ((access & Opcodes.ACC_ENUM) != 0) {
- resultType = new JEnumType(typeOracle, pkg, enclosingTypeName,
- isLocalType, className, isIntf);
+ resultType = newEnumType(pkg, enclosingTypeName, isLocalType, className);
} else {
JTypeParameter[] typeParams = getTypeParametersForClass(classData);
if ((typeParams != null && typeParams.length > 0)
@@ -444,8 +470,8 @@
resultType = new JGenericType(typeOracle, pkg, enclosingTypeName,
isLocalType, className, isIntf, typeParams);
} else {
- resultType = new JRealClassType(typeOracle, pkg, enclosingTypeName,
- isLocalType, className, isIntf);
+ resultType = newRealClassType(pkg, enclosingTypeName, isLocalType,
+ className, isIntf);
}
}
@@ -537,7 +563,7 @@
/**
* Map a bitset onto a different bitset.
- *
+ *
* @param mapping int array containing a sequence of from/to pairs, each from
* entry should have exactly one bit set
* @param input bitset to map
@@ -740,14 +766,14 @@
// Resolve annotations
Map<Class<? extends Annotation>, Annotation> declaredAnnotations = new HashMap<Class<? extends Annotation>, Annotation>();
resolveAnnotations(logger, classData.getAnnotations(), declaredAnnotations);
- type.addAnnotations(declaredAnnotations);
+ addAnnotations(type, declaredAnnotations);
String signature = classData.getSignature();
if (signature != null) {
// If we have a signature, use it for superclass and interfaces
SignatureReader reader = new SignatureReader(signature);
- ResolveClassSignature classResolver = new ResolveClassSignature(
- resolver, binaryMapper, logger, type, typeParamLookup);
+ ResolveClassSignature classResolver = new ResolveClassSignature(resolver,
+ binaryMapper, logger, type, typeParamLookup);
reader.accept(classResolver);
classResolver.finish();
} else {
@@ -761,7 +787,7 @@
+ superName);
return false;
}
- type.setSuperclass((JClassType) possiblySubstituteRawType(superType));
+ setSuperClass(type, (JClassType) possiblySubstituteRawType(superType));
}
}
@@ -772,7 +798,8 @@
logger.log(TreeLogger.WARN, "Unable to resolve interface " + intfName);
return false;
}
- type.addImplementedInterface((JClassType) possiblySubstituteRawType(intf));
+ addImplementedInterface(type,
+ (JClassType) possiblySubstituteRawType(intf));
}
}
if (((access & Opcodes.ACC_INTERFACE) == 0) && type.getSuperclass() == null) {
@@ -790,7 +817,7 @@
// Process fields
// Track the next enum ordinal across resolveField calls.
- int[] nextEnumOrdinal = new int[] {0};
+ int[] nextEnumOrdinal = new int[]{0};
for (CollectFieldData field : classData.getFields()) {
if (!resolveField(logger, type, field, typeParamLookup, nextEnumOrdinal)) {
logger.log(TreeLogger.WARN, "Unable to resolve field " + field);
@@ -870,9 +897,9 @@
// type variables, the enclosign type must be the raw type instead
// of the generic type.
JGenericType genericType = enclosingType.isGenericType();
- type.setEnclosingType(genericType.getRawType());
+ setEnclosingType(type, genericType.getRawType());
} else {
- type.setEnclosingType(enclosingType);
+ setEnclosingType(type, enclosingType);
}
}
}
@@ -888,15 +915,16 @@
JField jfield;
if ((field.getAccess() & Opcodes.ACC_ENUM) != 0) {
assert (type.isEnum() != null);
- jfield = new JEnumConstant(type, name, declaredAnnotations,
+ jfield = newEnumConstant(type, name, declaredAnnotations,
nextEnumOrdinal[0]++);
} else {
- jfield = new JField(type, name, declaredAnnotations);
+ JField newField = newField(type, name, declaredAnnotations);
+ jfield = newField;
}
// Get modifiers.
//
- jfield.addModifierBits(mapBits(ASM_TO_SHARED_MODIFIERS, field.getAccess()));
+ addModifierBits(jfield, mapBits(ASM_TO_SHARED_MODIFIERS, field.getAccess()));
String signature = field.getSignature();
JType fieldType;
@@ -917,7 +945,7 @@
if (fieldType == null) {
return false;
}
- jfield.setType(fieldType);
+ setFieldType(jfield, fieldType);
return true;
}
@@ -951,28 +979,27 @@
boolean hasReturnType = true;
if ("<init>".equals(name)) {
name = type.getSimpleSourceName();
- method = new JConstructor(type, name, declaredAnnotations, typeParams);
+ method = newConstructor(type, name, declaredAnnotations, typeParams);
hasReturnType = false;
} else {
if (type.isAnnotation() != null) {
- // TODO(jat): !! anything else to do here?
- method = new JAnnotationMethod(type, name, typeParams,
- declaredAnnotations);
+ // TODO(jat): actually resolve the default annotation value.
+ method = newAnnotationMethod(type, name, declaredAnnotations,
+ typeParams, null);
} else {
- method = new JMethod(type, name, declaredAnnotations, typeParams);
+ method = newMethod(type, name, declaredAnnotations, typeParams);
}
}
- // Copy modifier flags
- method.addModifierBits(mapBits(ASM_TO_SHARED_MODIFIERS,
+ addModifierBits(method, mapBits(ASM_TO_SHARED_MODIFIERS,
methodData.getAccess()));
if (type.isInterface() != null) {
// Always add implicit modifiers on interface methods.
- method.addModifierBits(Shared.MOD_PUBLIC | Shared.MOD_ABSTRACT);
+ addModifierBits(method, Shared.MOD_PUBLIC | Shared.MOD_ABSTRACT);
}
if ((methodData.getAccess() & Opcodes.ACC_VARARGS) != 0) {
- method.setVarArgs();
+ setVarArgs(method);
}
String signature = methodData.getSignature();
@@ -998,7 +1025,7 @@
if (returnJType == null) {
return false;
}
- ((JMethod) method).setReturnType(returnJType);
+ setReturnType(method, returnJType);
}
if (!resolveParameters(logger, method, methodData)) {
@@ -1027,7 +1054,7 @@
List<CollectAnnotationData> annotations) {
Map<Class<? extends Annotation>, Annotation> declaredAnnotations = new HashMap<Class<? extends Annotation>, Annotation>();
resolveAnnotations(logger, annotations, declaredAnnotations);
- type.getPackage().addAnnotations(declaredAnnotations);
+ addAnnotations(type.getPackage(), declaredAnnotations);
return true;
}
@@ -1053,8 +1080,7 @@
Map<Class<? extends Annotation>, Annotation> declaredAnnotations = new HashMap<Class<? extends Annotation>, Annotation>();
resolveAnnotations(logger, paramAnnot[i], declaredAnnotations);
- // JParameter adds itself to the method
- new JParameter(method, argType, argNames[i], declaredAnnotations,
+ newParameter(method, argType, argNames[i], declaredAnnotations,
argNamesAreReal);
}
return true;
@@ -1068,7 +1094,7 @@
if (exc == null) {
return false;
}
- method.addThrows(exc);
+ addThrows(method, exc);
}
}
return true;
diff --git a/dev/core/src/com/google/gwt/dev/javac/asm/ResolveClassSignature.java b/dev/core/src/com/google/gwt/dev/javac/asm/ResolveClassSignature.java
index c6e3ff6..79c3d3b 100644
--- a/dev/core/src/com/google/gwt/dev/javac/asm/ResolveClassSignature.java
+++ b/dev/core/src/com/google/gwt/dev/javac/asm/ResolveClassSignature.java
@@ -29,21 +29,21 @@
import java.util.Map;
/**
- * Signature visitor that resolves all the type variables and their bounds for
- * a given class.
+ * Signature visitor that resolves all the type variables and their bounds for a
+ * given class.
*/
public class ResolveClassSignature extends EmptySignatureVisitor {
- private final Resolver resolver;
private final Map<String, JRealClassType> binaryMapper;
- private final TreeLogger logger;
- private final JRealClassType type;
- private final TypeParameterLookup lookup;
-
- private JTypeParameter currentParam = null;
private ArrayList<JType[]> bounds = null;
- private JType[] superClass = new JType[1];
+ private JTypeParameter currentParam = null;
private List<JType[]> interfaces = new ArrayList<JType[]>();
+ private final TreeLogger logger;
+
+ private final TypeParameterLookup lookup;
+ private final Resolver resolver;
+ private JType[] superClass = new JType[1];
+ private final JRealClassType type;
public ResolveClassSignature(Resolver resolver,
Map<String, JRealClassType> binaryMapper, TreeLogger logger,
@@ -72,16 +72,15 @@
// The generic signature contains a superclass for interfaces,
// but TypeOracle doesn't like that -- verify that we were
// told Object is the superclass and ignore it.
- assert superClass[0].equals(
- resolver.getTypeOracle().getJavaLangObject());
+ assert superClass[0].equals(resolver.getTypeOracle().getJavaLangObject());
} else {
- type.setSuperclass((JClassType) superClass[0]);
+ resolver.setSuperClass(type, (JClassType) superClass[0]);
}
superClass[0] = null;
}
for (JType[] intfRef : interfaces) {
if (intfRef[0] != null) {
- type.addImplementedInterface((JClassType) intfRef[0]);
+ resolver.addImplementedInterface(type, (JClassType) intfRef[0]);
}
}
interfaces.clear();
@@ -128,7 +127,7 @@
@Override
public SignatureVisitor visitSuperclass() {
finish();
- return new ResolveTypeSignature(resolver, binaryMapper, logger,
- superClass, lookup, null);
+ return new ResolveTypeSignature(resolver, binaryMapper, logger, superClass,
+ lookup, null);
}
}
diff --git a/dev/core/src/com/google/gwt/dev/javac/asm/ResolveMethodSignature.java b/dev/core/src/com/google/gwt/dev/javac/asm/ResolveMethodSignature.java
index 8939958..ac6b5ef 100644
--- a/dev/core/src/com/google/gwt/dev/javac/asm/ResolveMethodSignature.java
+++ b/dev/core/src/com/google/gwt/dev/javac/asm/ResolveMethodSignature.java
@@ -18,8 +18,6 @@
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
import com.google.gwt.core.ext.typeinfo.JClassType;
-import com.google.gwt.core.ext.typeinfo.JMethod;
-import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.JTypeParameter;
import com.google.gwt.dev.asm.Type;
@@ -69,7 +67,7 @@
* @param argTypes
* @param argNames
* @param argNamesAreReal
- * @param allMethodArgs
+ * @param allMethodArgs
*/
public ResolveMethodSignature(Resolver resolver, TreeLogger logger,
JAbstractMethod method, TypeParameterLookup typeParamLookup,
@@ -99,7 +97,7 @@
// Set return type
if (hasReturnType) {
failed |= (returnType[0] == null);
- ((JMethod) method).setReturnType(returnType[0]);
+ resolver.setReturnType(method, returnType[0]);
}
// Create arguments
@@ -133,7 +131,7 @@
declaredAnnotations);
// JParameter adds itself to the method
- new JParameter(method, argType, names[i], declaredAnnotations,
+ resolver.newParameter(method, argType, names[i], declaredAnnotations,
namesAreReal);
}
@@ -143,7 +141,7 @@
failed = true;
continue;
}
- method.addThrows(exc[0]);
+ resolver.addThrows(method, exc[0]);
}
return !failed;
}
diff --git a/dev/core/test/com/google/gwt/core/ext/typeinfo/HookableTypeOracle.java b/dev/core/test/com/google/gwt/core/ext/typeinfo/HookableTypeOracle.java
deleted file mode 100644
index 2aed20b..0000000
--- a/dev/core/test/com/google/gwt/core/ext/typeinfo/HookableTypeOracle.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.google.gwt.core.ext.typeinfo;
-
-/**
- * A minimal TypeOracle mock that exposes the addNewType hook to subclasses.
- */
-public class HookableTypeOracle extends TypeOracle {
-
- // Increases visibility so tests in other packages can hook this.
- @Override
- protected void addNewType(JRealClassType newType) {
- super.addNewType(newType);
- }
-}
diff --git a/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java b/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java
index d6754d7..7c51802 100644
--- a/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java
+++ b/dev/core/test/com/google/gwt/dev/javac/TypeOracleTestingUtils.java
@@ -31,6 +31,31 @@
*/
public class TypeOracleTestingUtils {
+ public static TypeOracleMediator buildMediator(TreeLogger logger,
+ Set<Resource> resources, Set<GeneratedUnit> generatedUnits) {
+ CompilationState state = CompilationStateBuilder.buildFrom(logger,
+ resources);
+ state.addGeneratedCompilationUnits(logger, generatedUnits);
+ return state.getMediator();
+ }
+
+ public static TypeOracleMediator buildMediatorWith(TreeLogger logger,
+ Set<Resource> resources) {
+ return buildMediator(logger, resources,
+ Collections.<GeneratedUnit> emptySet());
+ }
+
+ public static TypeOracleMediator buildStandardMediatorWith(TreeLogger logger,
+ Resource... resources) {
+ return buildStandardMediatorWith(logger, new HashSet<Resource>(
+ Arrays.asList(resources)));
+ }
+
+ public static TypeOracleMediator buildStandardMediatorWith(TreeLogger logger,
+ Set<Resource> resources) {
+ return buildMediatorWith(logger, standardBuildersPlus(resources));
+ }
+
public static TypeOracle buildStandardTypeOracleWith(TreeLogger logger,
Resource... resources) {
return buildStandardTypeOracleWith(logger, new HashSet<Resource>(
diff --git a/dev/core/test/com/google/gwt/dev/javac/asm/ResolveGenericsTest.java b/dev/core/test/com/google/gwt/dev/javac/asm/ResolveGenericsTest.java
index 0ba5424..5210973 100644
--- a/dev/core/test/com/google/gwt/dev/javac/asm/ResolveGenericsTest.java
+++ b/dev/core/test/com/google/gwt/dev/javac/asm/ResolveGenericsTest.java
@@ -16,12 +16,13 @@
package com.google.gwt.dev.javac.asm;
import com.google.gwt.core.ext.TreeLogger;
-import com.google.gwt.core.ext.typeinfo.HookableTypeOracle;
+import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JGenericType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JPackage;
import com.google.gwt.core.ext.typeinfo.JRealClassType;
+import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.JTypeParameter;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.dev.asm.Opcodes;
@@ -29,6 +30,7 @@
import com.google.gwt.dev.asm.signature.SignatureReader;
import com.google.gwt.dev.javac.MethodArgNamesLookup;
import com.google.gwt.dev.javac.Resolver;
+import com.google.gwt.dev.javac.TypeOracleMediator;
import com.google.gwt.dev.javac.TypeOracleTestingUtils;
import com.google.gwt.dev.javac.TypeParameterLookup;
import com.google.gwt.dev.javac.asm.CollectClassData.ClassType;
@@ -37,8 +39,7 @@
import java.lang.reflect.Method;
import java.lang.reflect.TypeVariable;
import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
+import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
@@ -71,45 +72,72 @@
}
}
- /**
- * An extension of JMethod which keeps the reflected Method around.
- */
- public static class ReflectedMethod extends JMethod {
- private Method method;
+ private class MockResolver implements Resolver {
+ private final Resolver delegate;
- public ReflectedMethod(JClassType type, String methodName,
- Map<Class<? extends Annotation>, Annotation> annotations,
- JTypeParameter[] typeParams, Method method) {
- super(type, methodName, annotations, typeParams);
- this.method = method;
+ public MockResolver(Resolver resolver) {
+ this.delegate = resolver;
}
- public Method getMethod() {
- return method;
+ public void addImplementedInterface(JRealClassType type, JClassType intf) {
+ delegate.addImplementedInterface(type, intf);
}
- }
- public static class ResolverMockTypeOracle extends HookableTypeOracle {
-
- private Map<String, JRealClassType> binaryMapper;
+ public void addThrows(JAbstractMethod method, JType exception) {
+ delegate.addThrows(method, exception);
+ }
public Map<String, JRealClassType> getBinaryMapper() {
- ensureBinaryMapper();
- return binaryMapper;
+ return delegate.getBinaryMapper();
}
- @Override
- protected void addNewType(JRealClassType type) {
- super.addNewType(type);
- String name = type.getQualifiedBinaryName().replace('.', '/');
- ensureBinaryMapper();
- binaryMapper.put(name, type);
+ public TypeOracle getTypeOracle() {
+ return delegate.getTypeOracle();
}
- private void ensureBinaryMapper() {
- if (binaryMapper == null) {
- binaryMapper = new HashMap<String, JRealClassType>();
- }
+ public JMethod newMethod(JClassType type, String name,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ JTypeParameter[] typeParams) {
+ return delegate.newMethod(type, name, declaredAnnotations, typeParams);
+ }
+
+ public void newParameter(JAbstractMethod method, JType argType,
+ String argName,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations,
+ boolean argNamesAreReal) {
+ delegate.newParameter(method, argType, argName, declaredAnnotations,
+ argNamesAreReal);
+ }
+
+ public JRealClassType newRealClassType(JPackage pkg,
+ String enclosingTypeName, boolean isLocalType, String className,
+ boolean isIntf) {
+ return delegate.newRealClassType(pkg, enclosingTypeName, isLocalType,
+ className, isIntf);
+ }
+
+ public boolean resolveAnnotation(TreeLogger logger,
+ CollectAnnotationData annotVisitor,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ return true;
+ }
+
+ public boolean resolveAnnotations(TreeLogger logger,
+ List<CollectAnnotationData> annotations,
+ Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
+ return true;
+ }
+
+ public boolean resolveClass(TreeLogger logger, JRealClassType type) {
+ return true;
+ }
+
+ public void setReturnType(JAbstractMethod method, JType returnType) {
+ delegate.setReturnType(method, returnType);
+ }
+
+ public void setSuperClass(JRealClassType type, JClassType superType) {
+ delegate.setSuperClass(type, superType);
}
}
@@ -125,55 +153,34 @@
private static final String OUTER2_CLASS_SIG = "Lcom/google/gwt/dev/javac/asm/TestOuter1<Ljava/lang/String;>;";
private static final String OUTER2_METHOD_SIG = "(Lcom/google/gwt/dev/javac/asm/TestHandler1<Ljava/lang/String;>;)V";
- private final Map<String, JRealClassType> binaryMapper;
-
+ private final TypeOracleMediator mediator;
+
private final TypeOracle oracle;
+ private final Map<JMethod, Method> reflectionMethods = new IdentityHashMap<JMethod, Method>();
+
+ private final MockResolver resolver;
+
@SuppressWarnings("unused")
private JRealClassType testHandler;
@SuppressWarnings("unused")
private JRealClassType testHandler1;
private JRealClassType testOuter0;
+ private JMethod testOuter0dispatch;
private JRealClassType testOuter1;
- private JRealClassType testOuter2;
- private ReflectedMethod testOuter0dispatch;
- private ReflectedMethod testOuter1dispatch;
- private ReflectedMethod testOuter2dispatch;
+ private JMethod testOuter1dispatch;
+ private JRealClassType testOuter2;
+ private JMethod testOuter2dispatch;
@SuppressWarnings("unused")
private JRealClassType testType;
- private Resolver resolver = new Resolver() {
- public Map<String, JRealClassType> getBinaryMapper() {
- return binaryMapper;
- }
-
- public TypeOracle getTypeOracle() {
- return oracle;
- }
-
- public boolean resolveAnnotations(TreeLogger logger,
- List<CollectAnnotationData> annotations,
- Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
- return true;
- }
-
- public boolean resolveAnnotation(TreeLogger logger,
- CollectAnnotationData annotVisitor,
- Map<Class<? extends Annotation>, Annotation> declaredAnnotations) {
- return true;
- }
-
- public boolean resolveClass(TreeLogger logger, JRealClassType type) {
- return true;
- }
- };
-
public ResolveGenericsTest() {
- oracle = TypeOracleTestingUtils.buildStandardTypeOracleWith(failTreeLogger);
- createUnresolvedClass(Object.class, null);
+ mediator = TypeOracleTestingUtils.buildStandardMediatorWith(failTreeLogger);
+ resolver = new MockResolver(mediator.getResolver());
+ oracle = mediator.getTypeOracle();
createUnresolvedClass(String.class, null);
testHandler = createUnresolvedClass(TestHandler.class, null);
testHandler1 = createUnresolvedClass(TestHandler1.class, null);
@@ -187,10 +194,10 @@
"dispatch", TestHandler.class);
testOuter2dispatch = createUnresolvedMethod(testOuter2, TestOuter2.class,
"dispatch", TestHandler.class);
- binaryMapper = new LinkedHashMap<String, JRealClassType>();
for (JClassType type : oracle.getTypes()) {
if (type instanceof JRealClassType) {
- binaryMapper.put(type.getQualifiedBinaryName().replace('.', '/'),
+ mediator.getBinaryMapper().put(
+ type.getQualifiedBinaryName().replace('.', '/'),
(JRealClassType) type);
}
}
@@ -254,7 +261,7 @@
enclosingTypeName = enclosingType.getName();
}
if (n == 0) {
- type = new JRealClassType(oracle, pkg, enclosingTypeName, false,
+ type = resolver.newRealClassType(pkg, enclosingTypeName, false,
clazz.getSimpleName(), clazz.isInterface());
} else {
JTypeParameter[] params = createTypeParams(typeParams);
@@ -264,8 +271,8 @@
return type;
}
- private ReflectedMethod createUnresolvedMethod(JClassType type,
- Class<?> clazz, String methodName, Class<?>... paramTypes) {
+ private JMethod createUnresolvedMethod(JClassType type, Class<?> clazz,
+ String methodName, Class<?>... paramTypes) {
Method method = null;
try {
method = clazz.getMethod(methodName, paramTypes);
@@ -276,7 +283,9 @@
}
JTypeParameter[] typeParams = createTypeParams(method.getTypeParameters());
Map<Class<? extends Annotation>, Annotation> emptyMap = Collections.emptyMap();
- return new ReflectedMethod(type, methodName, emptyMap, typeParams, method);
+ JMethod result = resolver.newMethod(type, methodName, emptyMap, typeParams);
+ reflectionMethods.put(result, method);
+ return result;
}
private void resolveClassSignature(JRealClassType type, String signature) {
@@ -289,15 +298,16 @@
classResolver.finish();
}
- private void resolveMethodSignature(ReflectedMethod method, String signature) {
+ private void resolveMethodSignature(JMethod method, String signature) {
TypeParameterLookup lookup = new TypeParameterLookup();
lookup.pushEnclosingScopes(method.getEnclosingType());
lookup.pushScope(method.getTypeParameters());
int access = Opcodes.ACC_PUBLIC;
- String desc = Type.getMethodDescriptor(method.getMethod());
+ Method reflectionMethod = reflectionMethods.get(method);
+ String desc = Type.getMethodDescriptor(reflectionMethod);
CollectMethodData methodData = new CollectMethodData(ClassType.TopLevel,
access, method.getName(), desc, signature, null);
- Class<?>[] paramTypes = method.getMethod().getParameterTypes();
+ Class<?>[] paramTypes = reflectionMethod.getParameterTypes();
int n = paramTypes.length;
Type[] argTypes = new Type[n];
String[] argNames = new String[n];
