Skip to content

Commit

Permalink
Simplify the implementation of constructorFromUse
Browse files Browse the repository at this point in the history
  • Loading branch information
@Ao-senXiong
Ao-senXiong committed Mar 1, 2024
1 parent 28f99a8 commit 53b76fa
Showing 1 changed file with 2 additions and 131 deletions.
133 changes: 2 additions & 131 deletions src/checkers/inference/InferenceAnnotatedTypeFactory.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -396,139 +396,10 @@ public ParameterizedExecutableType constructorFromUse(final NewClassTree newClas
(AnnotatedDeclaredType) toAnnotatedType(TreeUtils.typeOf(newClassTree), false);
addComputedTypeAnnotations(newClassTree, constructorReturnType);

if (!TreeUtils.isDiamondTree(newClassTree)) {
if (newClassTree.getClassBody() == null) {
constructorReturnType.setTypeArguments(getExplicitNewClassClassTypeArgs(newClassTree));
}
} else {
constructorReturnType = getAnnotatedType(TypesUtils.getTypeElement(constructorReturnType.underlyingType));
// Add explicit annotations below.
constructorReturnType.clearAnnotations();
}

AnnotationMirrorSet explicitAnnos = getExplicitNewClassAnnos(newClassTree);
constructorReturnType.addAnnotations(explicitAnnos);

// Get the enclosing type of the constructor, if one exists.
// this.new InnerClass()
AnnotatedDeclaredType enclosingType = (AnnotatedDeclaredType) getReceiverType(newClassTree);
constructorReturnType.setEnclosingType(enclosingType);

// Add computed annotations to the type.
addComputedTypeAnnotations(newClassTree, constructorReturnType);

// final AnnotatedExecutableType constructorType = AnnotatedTypes.asMemberOf(types, this, constructorReturnType, constructorElem);
ExecutableElement ctor = TreeUtils.elementFromUse(newClassTree);
AnnotatedExecutableType constructorType = getAnnotatedType(ctor); // get unsubstituted type
constructorFromUsePreSubstitution(newClassTree, constructorType);

if (viewpointAdapter != null) {
viewpointAdapter.viewpointAdaptConstructor(constructorReturnType, constructorElem, constructorType);
}

if (newClassTree.getClassBody() != null) {
// Because the anonymous constructor can't have explicit annotations on its parameters,
// they are copied from the super constructor invoked in the anonymous constructor. To
// do this:
// 1. get unsubstituted type of the super constructor.
// 2. adapt it to this call site.
// 3. compute and store the vararg type.
// 4. copy the parameters to the anonymous constructor, `con`.
// 5. copy annotations on the return type to `con`.
AnnotatedExecutableType superCon =
getAnnotatedType(TreeUtils.getSuperConstructor(newClassTree));
constructorFromUsePreSubstitution(newClassTree, superCon);
// no viewpoint adaptation needed for super invocation
superCon =
AnnotatedTypes.asMemberOf(types, this, constructorReturnType, superCon.getElement(), superCon);
constructorType.computeVarargType(superCon);
if (superCon.getParameterTypes().size() == constructorType.getParameterTypes().size()) {
constructorType.setParameterTypes(superCon.getParameterTypes());
} else {
// If the super class of the anonymous class has an enclosing type, then it is the
// first parameter of the anonymous constructor. For example,
// class Outer { class Inner {} }
// new Inner(){};
// Then javac creates the following constructor:
// (.Outer x0) {
// x0.super();
// }
// So the code below deals with this.
List<AnnotatedTypeMirror> p =
new ArrayList<>(superCon.getParameterTypes().size() + 1);
if (TreeUtils.hasSyntheticArgument(newClassTree)) {
p.add(constructorType.getParameterTypes().get(0));
constructorType.setReceiverType(superCon.getReceiverType());
} else if (constructorType.getReceiverType() != null) {
// Because the anonymous constructor doesn't have annotated receiver type,
// we copy the receiver type from the super constructor invoked in the anonymous
// constructor and add it to the parameterTypes as the first element.
constructorType.setReceiverType(superCon.getReceiverType());
p.add(constructorType.getReceiverType());
} else {
p.add(constructorType.getParameterTypes().get(0));
}
p.addAll(1, superCon.getParameterTypes());
constructorType.setParameterTypes(Collections.unmodifiableList(p));
}
constructorType.getReturnType().replaceAnnotations(superCon.getReturnType().getAnnotations());
} else {
// Store varargType before calling setParameterTypes, otherwise we may lose the
// varargType as it is the last element of the original parameterTypes.
// AnnotatedTypes.asMemberOf handles vararg type properly, so we do not need to compute
// vararg type again.
constructorType.computeVarargType();
constructorType = AnnotatedTypes.asMemberOf(types, this, constructorReturnType, ctor, constructorType);
}

Map<TypeVariable, AnnotatedTypeMirror> typeParamToTypeArg =
AnnotatedTypes.findTypeArguments(processingEnv, this, newClassTree, ctor, constructorType);
List<AnnotatedTypeMirror> typeargs;
if (typeParamToTypeArg.isEmpty()) {
typeargs = Collections.emptyList();
} else {
typeargs =
CollectionsPlume.mapList(
(AnnotatedTypeMirror.AnnotatedTypeVariable tv) ->
typeParamToTypeArg.get(tv.getUnderlyingType()),
constructorType.getTypeVariables());
}
if (TreeUtils.isDiamondTree(newClassTree)) {
// TODO: This should be done at the same time as type argument inference.
List<AnnotatedTypeMirror> classTypeArgs = inferDiamondType(newClassTree);
int i = 0;
for (AnnotatedTypeMirror typeParam : constructorReturnType.getTypeArguments()) {
typeParamToTypeArg.put(
(TypeVariable) typeParam.getUnderlyingType(), classTypeArgs.get(i));
i++;
}
}
constructorType = (AnnotatedExecutableType) typeVarSubstitutor.substitute(typeParamToTypeArg, constructorType);

stubTypes.injectRecordComponentType(types, ctor, constructorType);
if (enclosingType != null) {
// Reset the enclosing type because it can be substituted incorrectly.
((AnnotatedDeclaredType) constructorType.getReturnType()).setEnclosingType(enclosingType);
}

// Take adapt parameter logic from AnnotatedTypeFactory#constructorFromUse to
// InferenceAnnotatedTypeFactory#constructorFromUse.
// Store varargType before calling setParameterTypes, otherwise we may lose the
// varargType as it is the last element of the original parameterTypes.
// AnnotatedTypes.asMemberOf handles vararg type properly, so we do not need to compute
// vararg type again.
constructorType.computeVarargType();
// Adapt parameters, which makes parameters and arguments be the same size for later
// checking. The vararg type of con has been already computed and stored when calling
// typeVarSubstitutor.substitute.
List<AnnotatedTypeMirror> parameters =
AnnotatedTypes.adaptParameters(this, constructorType, newClassTree.getArguments());
constructorType.setParameterTypes(parameters);

ParameterizedExecutableType substitutedPair = substituteTypeArgs(newClassTree, constructorElem, constructorType);
ParameterizedExecutableType result = super.constructorFromUse(newClassTree);
ParameterizedExecutableType substitutedPair = substituteTypeArgs(newClassTree, constructorElem, result.executableType);
inferencePoly.replacePolys(newClassTree, substitutedPair.executableType);

// TODO: Should we be doing asMemberOf like super?
return substitutedPair;
}

Expand Down

0 comments on commit 53b76fa

Please sign in to comment.