Resolve null warnings: make null-strategy better analyzable.
diff --git a/org.eclipse.jdt.core/.settings/org.eclipse.jdt.core.prefs b/org.eclipse.jdt.core/.settings/org.eclipse.jdt.core.prefs
index 4b18916..67de71f 100644
--- a/org.eclipse.jdt.core/.settings/org.eclipse.jdt.core.prefs
+++ b/org.eclipse.jdt.core/.settings/org.eclipse.jdt.core.prefs
@@ -41,7 +41,7 @@
org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
-org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
+org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=enabled
org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=warning
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/CompilationResult.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/CompilationResult.java
index 1aded9e..5f2fa61 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/CompilationResult.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/CompilationResult.java
@@ -55,6 +55,7 @@
import java.util.Set;
import org.eclipse.core.runtime.IPath;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;
@@ -164,7 +165,7 @@
ReferenceContext context;
boolean ignoreFurtherInvestigation;
}
-public CheckPoint getCheckPoint(ReferenceContext referenceContext) {
+public @NonNull CheckPoint getCheckPoint(ReferenceContext referenceContext) {
CheckPoint result = new CheckPoint();
if (this.problems != null) {
int len = this.problems.length;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/BaseCallMessageSend.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/BaseCallMessageSend.java
index 6fe28ae..0a9cc19 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/BaseCallMessageSend.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/BaseCallMessageSend.java
@@ -313,8 +313,11 @@
} else {
for (int i=0; i<sourceArgsLen; i++) {
TypeBinding srcArgType = this.sourceArgs[i].resolvedType;
- if (srcArgType == null && callinMethodDecl.hasErrors())
+ if (srcArgType == null) {
+ if (!callinMethodDecl.hasErrors())
+ throw new InternalCompilerError("Unexpected: srcArgType should only ever be missing in declarations with reported errors"); //$NON-NLS-1$
continue;
+ }
if (!srcArgType.isCompatibleWith(methodParams[i])) {
if (isBoxingCompatible(srcArgType, methodParams[i], this.sourceArgs[i], scope)) {
int enhancedArgIdx = i+MethodSignatureEnhancer.ENHANCING_ARG_LEN+1; // normal enhancement plus isSuperAccess flag
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLiftExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLiftExpression.java
index f720754..9d59444 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLiftExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLiftExpression.java
@@ -131,18 +131,15 @@
baseType = providedType;
roleSideType = this.expectedType;
}
- boolean incompatibilityFound = false;
ReferenceBinding roleType = null;
if (!(baseType instanceof ReferenceBinding)) {
- incompatibilityFound = true;
+ return reportIncompatibility(scope, providedType);
} else {
roleType = (ReferenceBinding)roleSideType;
if ( !roleType.isDirectRole()
|| !(baseType instanceof ReferenceBinding))
- incompatibilityFound = true;
+ return reportIncompatibility(scope, providedType);
}
- if (incompatibilityFound)
- return reportIncompatibility(scope, providedType);
// reset Config, because below we want to check loweringRequired.
Config oldConfig = Config.createOrResetConfig(this);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLowerExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLowerExpression.java
index 6954455..bf6c629 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLowerExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PotentialLowerExpression.java
@@ -100,18 +100,15 @@
roleSideType = rawType;
baseType = this.expectedType;
}
- boolean incompatibilityFound = false;
ReferenceBinding roleType = null;
if (!(roleSideType instanceof ReferenceBinding)) {
- incompatibilityFound = true;
+ return reportIncompatibility(scope, rawType);
} else {
roleType = (ReferenceBinding)roleSideType;
if ( !roleType.isDirectRole()
|| !(baseType instanceof ReferenceBinding))
- incompatibilityFound = true;
+ return reportIncompatibility(scope, rawType);
}
- if (incompatibilityFound)
- return reportIncompatibility(scope, rawType);
boolean oldLower = Config.getLoweringRequired();
try {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PrecedenceDeclaration.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PrecedenceDeclaration.java
index a4b8926..2577b33 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PrecedenceDeclaration.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/PrecedenceDeclaration.java
@@ -253,8 +253,10 @@
for (int i = 0; i < len; i++) {
precedences[i] = type.binding.precedences[i];
}
- for (int i = 0; i < lenSuper; i++) {
- precedences[len+i] = strengthenPrecendence(type, superTeam.precedences[i]);
+ if (superTeam != null) { // redundant as per correlation with lenSuper
+ for (int i = 0; i < lenSuper; i++) {
+ precedences[len+i] = strengthenPrecendence(type, superTeam.precedences[i]);
+ }
}
int count = precedences.length;
for(int i=0; i<precedences.length-1; i++) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TSuperMessageSend.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TSuperMessageSend.java
index 95bba67..2dadfd5 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TSuperMessageSend.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TSuperMessageSend.java
@@ -144,7 +144,7 @@
for (int i=tsuperRoleBindings.length-1; i>=0; i--) {
ReferenceBinding tsuperRole = tsuperRoleBindings[i];
MethodBinding candidate = scope.getMethod(tsuperRole, this.selector, argumentTypes, this);
- if (candidate != null && candidate.isValidBinding()) {
+ if (candidate.isValidBinding()) {
if (scope.parameterCompatibilityLevel(candidate, argumentTypes) != Scope.COMPATIBLE) {
scope.problemReporter().tsuperCallsWrongMethod(this);
return null;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TypeAnchorReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TypeAnchorReference.java
index 72d4b50..c61f923 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TypeAnchorReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/ast/TypeAnchorReference.java
@@ -475,7 +475,7 @@
anchorBinding = (ITeamAnchor)((NameReference)this.anchor).binding;
else if (this.anchor instanceof FieldReference)
anchorBinding = ((FieldReference)this.anchor).binding;
- if( type != null
+ if( anchorBinding != null
&& type instanceof ReferenceBinding
&& type.isValidBinding())
{
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/bytecode/SingleValueAttribute.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/bytecode/SingleValueAttribute.java
index 2bfd507..8b08afa 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/bytecode/SingleValueAttribute.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/bytecode/SingleValueAttribute.java
@@ -196,6 +196,7 @@
else if (staticPart != null)
break; // seen enough
}
+ if (staticPart == null) return; // no success!
ReferenceBinding currentType = staticPart;
ITeamAnchor anchor = null; // accumulate anchor path here
while (i<anchorPath.length) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/control/Config.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/control/Config.java
index c8ff00a..6e77792 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/control/Config.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/control/Config.java
@@ -325,9 +325,12 @@
public static void setSourceTypeRequired(boolean val) {
Config config = getConfig();
- if (config == null && !val)
- return; // ignore attempt to reset while no Config is configured
- config.sourceTypeRequired = val;
+ if (config == null) {
+ if (!val) return; // ignore attempt to *reset* while no Config is configured
+ throw new NullPointerException("Not configured when requesting source type."); //$NON-NLS-1$
+ } else {
+ config.sourceTypeRequired = val;
+ }
}
public static boolean getSourceTypeRequired() {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java
index c7a6a72..7d06516 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/DeclaredLifting.java
@@ -745,7 +745,8 @@
/* Generate the if-cascade for dynamic lifting depending on the argument's dynamic type. */
static Statement generateDynamicSwitch(BlockScope scope, ReferenceBinding roleType, int problemId, AstGenerator gen) {
ReferenceBinding[] boundDescendants = roleType.roleModel.getBoundDescendants();
- if (boundDescendants.length == 0)
+ int len = boundDescendants.length;
+ if (len == 0)
return gen.throwStatement(
gen.allocation(
gen.qualifiedTypeReference(TypeConstants.JAVA_LANG_ERROR),
@@ -755,49 +756,54 @@
"Lifting impossible, role has no bound descendants: ".toCharArray(), //$NON-NLS-1$
roleType.readableName()))
}));
- IfStatement ifStat = null;
- IfStatement current = null;
LookupEnvironment environment = scope.compilationUnitScope().environment;
- for (int i=0; i<boundDescendants.length; i++) {
- TypeBinding boundBase = boundDescendants[i].baseclass();
- if (RoleTypeBinding.isRoleWithExplicitAnchor(boundBase)) {
- if (boundBase.isParameterizedType()) {
- // tricky case: need to discard type parameters, but retain/recreate the role type wrapping:
- RoleTypeBinding baseRole = (RoleTypeBinding)boundBase;
- boundBase = environment.createParameterizedType(baseRole._declaredRoleType,
- null, // erase type parameters
- baseRole._teamAnchor, // but retain anchor
- -1, // valueParamPosition
- baseRole.enclosingType());
- }
- // only RTB but not parameterized: leave unchanged.
- } else {
- boundBase = boundBase.erasure();
- }
- IfStatement newIf = gen.ifStatement(
- gen.instanceOfExpression(
- gen.singleNameReference(IOTConstants.BASE),
- gen.typeReference(boundBase)),
- gen.returnStatement(
- Lifting.liftCall(
- scope,
- gen.thisReference(),
- gen.castExpression(
- gen.singleNameReference(IOTConstants.BASE),
- gen.typeReference(boundBase),
- CastExpression.DO_WRAP),
- boundBase,
- boundDescendants[i],
- false/*needLowering*/)),
- null);
- if (ifStat == null)
- ifStat = newIf; // toplevel "if"
- else
- current.elseStatement = newIf; // nest within existing "if else { /* here */ }"
+ // toplevel "if"
+ IfStatement ifStat = genNewIf(scope, gen, boundDescendants[0], environment);
+ IfStatement current = ifStat;
+ // needed at least one if, nested ifs are optional:
+ for (int i=1; i<len; i++) {
+ IfStatement newIf = genNewIf(scope, gen, boundDescendants[i], environment);
+ current.elseStatement = newIf; // nest within existing "if else { /* here */ }"
current = newIf;
}
// final branch:
current.elseStatement = Lifting.genLiftingFailedException(IOTConstants.BASE, roleType, problemId, gen);
return ifStat;
}
+
+ private static IfStatement genNewIf(BlockScope scope, AstGenerator gen, ReferenceBinding boundDescendant,
+ LookupEnvironment environment)
+ {
+ TypeBinding boundBase = boundDescendant.baseclass();
+ if (RoleTypeBinding.isRoleWithExplicitAnchor(boundBase)) {
+ if (boundBase.isParameterizedType()) {
+ // tricky case: need to discard type parameters, but retain/recreate the role type wrapping:
+ RoleTypeBinding baseRole = (RoleTypeBinding)boundBase;
+ boundBase = environment.createParameterizedType(baseRole._declaredRoleType,
+ null, // erase type parameters
+ baseRole._teamAnchor, // but retain anchor
+ -1, // valueParamPosition
+ baseRole.enclosingType());
+ }
+ // only RTB but not parameterized: leave unchanged.
+ } else {
+ boundBase = boundBase.erasure();
+ }
+ return gen.ifStatement(
+ gen.instanceOfExpression(
+ gen.singleNameReference(IOTConstants.BASE),
+ gen.typeReference(boundBase)),
+ gen.returnStatement(
+ Lifting.liftCall(
+ scope,
+ gen.thisReference(),
+ gen.castExpression(
+ gen.singleNameReference(IOTConstants.BASE),
+ gen.typeReference(boundBase),
+ CastExpression.DO_WRAP),
+ boundBase,
+ boundDescendant,
+ false/*needLowering*/)),
+ null);
+ }
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/Lowering.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/Lowering.java
index 1f147e3..d332642 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/Lowering.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/Lowering.java
@@ -20,6 +20,7 @@
**********************************************************************/
package org.eclipse.objectteams.otdt.internal.core.compiler.lifting;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.Assignment;
@@ -172,6 +173,7 @@
}
if (needNullCheck) {
// ((local = (expression)) == null) ? (RequiredType)local : lower(local));
+ @SuppressWarnings("null") // needNullCheck => localVar != null
SingleNameReference lhs = gen.singleNameReference(localVar.name);
lhs.binding = localVar;
lhs.resolvedType = unloweredType;
@@ -185,7 +187,7 @@
return loweringExpr;
}
- LocalVariableBinding makeNewLocal(BlockScope scope, TypeBinding variableType, int sourceStart, int sourceEnd) {
+ @NonNull LocalVariableBinding makeNewLocal(BlockScope scope, TypeBinding variableType, int sourceStart, int sourceEnd) {
char[] name = ("_OT$unlowered$"+sourceStart).toCharArray(); //$NON-NLS-1$
LocalVariableBinding varBinding = new LocalVariableBinding(name, variableType, 0, false);
varBinding.declaration = new LocalDeclaration(name, sourceStart, sourceEnd); // needed for BlockScope.computeLocalVariablePositions() -> CodeStream.record()
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java
index 7bf08fb..9f6867b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AbstractOTReferenceBinding.java
@@ -36,6 +36,7 @@
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
+import org.eclipse.objectteams.otdt.core.exceptions.InternalCompilerError;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.RoleModel;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.TeamModel;
import org.eclipse.objectteams.otdt.internal.core.compiler.model.TypeModel;
@@ -226,6 +227,8 @@
else if (CharOperation.equals(memberTypes[i].name, IOTConstants.CONFINED))
confinedIfc = memberTypes[i];
}
+ if (confinedClass == null || confinedIfc == null)
+ throw new InternalCompilerError("required type Team.Confined not found"); //$NON-NLS-1$
confinedClass.getRoleModel()._interfacePart = confinedIfc;
confinedIfc.getRoleModel()._classPart = confinedClass;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AnchorMapping.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AnchorMapping.java
index fbcd99e..6f99479 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AnchorMapping.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/AnchorMapping.java
@@ -202,7 +202,7 @@
}
}
}
- if (isValidAnchor(anchor)) {
+ if ((anchor=validAnchor(anchor)) != null) {
// downgrading allowed:
return anchor.getRoleTypeBinding(paramDependentType, typeArguments, dimensions);
}
@@ -252,9 +252,10 @@
reportError ? problemReporter : null,
null);
}
- if (!isValidAnchor(anchor))
- anchor = TThisBinding.getTThisForRole(roleRef, site);
- if (isValidAnchor(anchor))
+ anchor = validAnchor(anchor);
+ if (anchor == null)
+ anchor = validAnchor(TThisBinding.getTThisForRole(roleRef, site));
+ if (anchor != null)
{
if (!anchor.isTypeCompatibleWith(tthisType))
anchor = null; // cancel if incompatible.
@@ -262,11 +263,13 @@
}
return anchor;
}
- private boolean isValidAnchor(ITeamAnchor anchor) {
- return
- (anchor != null)
- && (anchor != RoleTypeBinding.NoAnchor)
- && anchor.isValidAnchor();
+ // if anchor is valid return it otherwise null
+ private ITeamAnchor validAnchor(ITeamAnchor anchor) {
+ if ( (anchor != null)
+ && (anchor != RoleTypeBinding.NoAnchor)
+ && anchor.isValidAnchor())
+ return anchor;
+ return null;
}
/** Store successful instantiated parameters in the current mapping. */
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java
index bb21cbb..32dd4f2 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lookup/TeamAnchor.java
@@ -277,13 +277,10 @@
if (expression instanceof QualifiedNameReference) {
FieldBinding[] otherFields = ((QualifiedNameReference)expression).otherBindings;
if (otherFields != null && otherFields.length > 0) {
- ITeamAnchor anchor = null;
- for (int i = otherFields.length-1; i >= 0; i--) {
- if (anchor == null)
- anchor = otherFields[i];
- else
- anchor = anchor.setPathPrefix(otherFields[i]);
- }
+ int len = otherFields.length;
+ ITeamAnchor anchor = otherFields[len-1];
+ for (int i = len-2; i >= 0; i--)
+ anchor = anchor.setPathPrefix(otherFields[i]);
if (bind instanceof ITeamAnchor)
return anchor.setPathPrefix((ITeamAnchor)bind);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java
index 1e6b298..393328e 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CallinImplementor.java
@@ -769,7 +769,7 @@
ReferenceBinding roleVarType = roleModel.getInterfacePartBinding();
// does lifting use type parameters? If so, use the same types as type arguments for the role variable
MethodBinding[] liftMethod = roleVarType.enclosingType().getMethods(liftCall.selector);
- if (liftMethod != null & liftMethod.length > 0) {
+ if (liftMethod != null && liftMethod.length > 0) {
TypeBinding[] typeArguments = liftMethod[0].typeVariables();
if (typeArguments != Binding.NO_TYPE_VARIABLES)
try {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CalloutImplementor.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CalloutImplementor.java
index 73e5f5b..fd70367 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CalloutImplementor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/mappings/CalloutImplementor.java
@@ -361,15 +361,16 @@
boolean overridesExplicitNonRole = false;
ReferenceBinding superRole = null;
ReferenceBinding roleClass = this._role.getClassPartBinding();
- if (roleClass != null)
+ if (roleClass != null) {
superRole = roleClass.superclass();
- if ( superRole != null // have a super class
- && superRole.enclosingType() != roleClass.enclosingType()) // not a role from current team // (superRole != null) => (roleClass != null)
- {
- MethodBinding superMethod = TypeAnalyzer.findMethod(
- calloutBindingDeclaration.scope, superRole, templateBinding.selector, templateBinding.parameters);
- if (superMethod != null && superMethod.isValidBinding())
- overridesExplicitNonRole = true; // TODO(SH): need compatibility checks? (a la MethodVerifier??)
+ if ( superRole != null // have a super class
+ && superRole.enclosingType() != roleClass.enclosingType()) // not a role from current team
+ {
+ MethodBinding superMethod = TypeAnalyzer.findMethod(
+ calloutBindingDeclaration.scope, superRole, templateBinding.selector, templateBinding.parameters);
+ if (superMethod != null && superMethod.isValidBinding())
+ overridesExplicitNonRole = true; // TODO(SH): need compatibility checks? (a la MethodVerifier??)
+ }
}
if (calloutBindingDeclaration.binding.inferred == InferenceKind.NONE) { // don't advertise inferred callout via the interface.
@@ -694,8 +695,10 @@
adjustBaseSideType(baseMethodSpec.resolvedType()));
return arguments;
} else {
+ if (roleArgs == null)
+ return new Expression[0];
TypeBinding[] baseParams = baseMethodSpec.resolvedMethod.parameters;
- minArguments = Math.min(baseParams.length, (roleArgs != null) ? roleArgs.length : 0); // (minArguments > 0) => (roleArgs != null)
+ minArguments = Math.min(baseParams.length, roleArgs.length);
assert(minArguments == baseParams.length);
arguments = new Expression[minArguments];
for(int i=0; i<minArguments; i++)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/copyinheritance/CopyInheritance.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/copyinheritance/CopyInheritance.java
index a8fa78d..35ba3c8 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/copyinheritance/CopyInheritance.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/copyinheritance/CopyInheritance.java
@@ -1378,13 +1378,15 @@
Argument[] newArguments = null;
// Arguments (construct from bindings, using dummy names):
- TypeBinding[] srcParams = constructorBinding != null ? constructorBinding.parameters : null;
- if (srcParams != null) {
- newArguments = AstConverter.createArgumentsFromParameters(srcParams, gen);
- if (srcParams.length == 1 && srcParams[0] == roleModel.getInterfacePartBinding()) { // single argument of type of this role itself?
- if (constructorBinding.isPrivate() || constructorBinding.isDefault()) // srcParams != null => constructorBinding != null
- roleModel.getAst().scope.problemReporter().roleConstructorHiddenByLiftingConstructor(constructor);
- }
+ if (constructorBinding != null) {
+ TypeBinding[] srcParams = constructorBinding.parameters;
+ if (srcParams != null) {
+ newArguments = AstConverter.createArgumentsFromParameters(srcParams, gen);
+ if (srcParams.length == 1 && srcParams[0] == roleModel.getInterfacePartBinding()) { // single argument of type of this role itself?
+ if (constructorBinding.isPrivate() || constructorBinding.isDefault())
+ roleModel.getAst().scope.problemReporter().roleConstructorHiddenByLiftingConstructor(constructor);
+ }
+ }
}
if (newArguments != null && constructorBinding != null && Lifting.isLiftingCtor(constructorBinding))
newArguments[0].type.setBaseclassDecapsulation(DecapsulationState.REPORTED);
@@ -1400,9 +1402,11 @@
if (constructor != null) {
if (constructor.thrownExceptions != null)
exceptions = AstClone.copyTypeArray(constructor.thrownExceptions);
- } else {
+ } else if (constructorBinding != null) {
if (constructorBinding.thrownExceptions != Binding.NO_EXCEPTIONS)
exceptions = AstClone.copyExceptions(constructorBinding, gen);
+ } else {
+ throw new InternalCompilerError("Either constructor or constructorBinding must be nonnull"); //$NON-NLS-1$
}
MethodDeclaration newMethod = internalCreateCreationMethod(
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/MethodSignatureEnhancer.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/MethodSignatureEnhancer.java
index 41fbb57..2249e7a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/MethodSignatureEnhancer.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/MethodSignatureEnhancer.java
@@ -200,7 +200,7 @@
};
int prefixLen = 0;
// base arg?
- if (isWrapper)
+ if (isWrapper && arguments != null)
newArgs[prefixLen++] = arguments[0];
// enhancing args:
for (int i=0; i<ENHANCING_ARG_LEN; i++)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/PredicateGenerator.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/PredicateGenerator.java
index ec90a01..2f53732 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/PredicateGenerator.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/PredicateGenerator.java
@@ -337,11 +337,12 @@
* passing to a sub role's predicate. */
private Expression baseReference(char[] baseVarName, ReferenceBinding roleType, AstGenerator gen) {
Expression result= gen.singleNameReference(baseVarName);
- if (( roleType != null
- && (roleType.baseclass() != this._currentRole.baseclass()))
- || CallinImplementorDyn.DYNAMIC_WEAVING) // under OTREDyn base is passed as IBoundBase => always need to cast.
- {
- result= gen.castExpression(result, gen.baseTypeReference(roleType.baseclass()), CastExpression.RAW);
+ if (roleType != null) {
+ if ( (roleType.baseclass() != this._currentRole.baseclass())
+ || CallinImplementorDyn.DYNAMIC_WEAVING) // under OTREDyn base is passed as IBoundBase => always need to cast.
+ {
+ result= gen.castExpression(result, gen.baseTypeReference(roleType.baseclass()), CastExpression.RAW);
+ }
}
return result;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/RoleSplitter.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/RoleSplitter.java
index 769b331..18e5aad 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/RoleSplitter.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/RoleSplitter.java
@@ -428,6 +428,7 @@
if (superClass.isDirectRole()) {
TypeDeclaration interfaceAst = role.getInterfaceAst();
if (interfaceAst != null) {
+ ifcPart = interfaceAst.binding;
ReferenceBinding superIfc = superClass.enclosingType().getMemberType(superClass.sourceName());
superIfc = superClass.transferTypeArguments(superIfc);
// special: linking an ifc from a custom Confined type to "Confined" from the correct team
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/SwitchOnBaseTypeGenerator.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/SwitchOnBaseTypeGenerator.java
index 3e8eff3..c8fb868 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/SwitchOnBaseTypeGenerator.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/SwitchOnBaseTypeGenerator.java
@@ -145,7 +145,7 @@
* else
* <default action>
*/
- prevIf.elseStatement = createDefaultStatement(staticRoleType, problemId, gen);
+ prevIf.elseStatement = createDefaultStatement(staticRoleType, problemId, gen); // prevIf should be set after at least one iteration into the else-branch
return gen.block(stmts);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/AstConverter.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/AstConverter.java
index 21fbc94..da928ae 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/AstConverter.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/AstConverter.java
@@ -450,8 +450,10 @@
foundMethod.isCopied = false;
foundMethod.isGenerated = true;
foundMethod.modifiers &= ~(AccAbstract|AccSemicolonBody);
- for (int i = 0; i < argumentsCount; i++) {
- foundMethod.arguments[i].updateName(arguments[i].name);
+ if (arguments != null) { // redundant via correlation with argumentsCount
+ for (int i = 0; i < argumentsCount; i++) {
+ foundMethod.arguments[i].updateName(arguments[i].name);
+ }
}
if (foundMethod.binding != null) {
foundMethod.binding.modifiers &= ~(AccAbstract);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/IAlienScopeTypeReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/IAlienScopeTypeReference.java
index 15be70e..56d91f4 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/IAlienScopeTypeReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/IAlienScopeTypeReference.java
@@ -67,7 +67,7 @@
return result;
// remove problem binding if any:
this.resolvedType = null;
- if (cp != null)
+ if (cp != null && referenceContext != null) // 2. check redundant via correlation
referenceContext.compilationResult.rollBack(cp);
return super.resolveType(this.alienScope.classScope());
}
@@ -103,7 +103,7 @@
return result;
// remove problem binding if any:
this.resolvedType = null;
- if (cp != null)
+ if (cp != null && referenceContext != null) // 2. check redundant via correlation
referenceContext.compilationResult.rollBack(cp);
return super.resolveType(this.alienScope.classScope());
}
@@ -147,7 +147,7 @@
return result;
// remove problem binding if any:
this.resolvedType = null;
- if (cp != null)
+ if (cp != null && referenceContext != null) // 2. check redundant via correlation
referenceContext.compilationResult.rollBack(cp);
return super.resolveType(this.alienScope.classScope());
}
@@ -182,7 +182,7 @@
return result;
// reset:
this.resolvedType = null;
- if (cp != null)
+ if (cp != null && referenceContext != null) // 2. check redundant via correlation
referenceContext.compilationResult.rollBack(cp);
return super.resolveType(this.alienScope.classScope());
}
@@ -222,7 +222,7 @@
return result;
// reset:
this.resolvedType = null;
- if (cp != null)
+ if (cp != null && referenceContext != null) // 2. check redundant via correlation
referenceContext.compilationResult.rollBack(cp);
return super.resolveType(this.alienScope.classScope());
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/RoleTypeCreator.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/RoleTypeCreator.java
index 1c0b7ce..059c0f3 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/RoleTypeCreator.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/util/RoleTypeCreator.java
@@ -20,6 +20,7 @@
**********************************************************************/
package org.eclipse.objectteams.otdt.internal.core.compiler.util;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.internal.compiler.CompilationResult;
@@ -96,8 +97,7 @@
for (int i = 0; i < arguments.length; i++)
{
TypeBinding arg = genericType.arguments[i];
- if ( arg != null
- && arg instanceof ReferenceBinding
+ if ( arg instanceof ReferenceBinding
&& !arg.isTypeVariable())
arguments[i] = updateArg((ReferenceBinding)arg);
else
@@ -674,10 +674,9 @@
* @param decl AST
*/
public static void wrapTypesInMethodDeclSignature (
- MethodBinding method, AbstractMethodDeclaration decl)
+ MethodBinding method, @NonNull AbstractMethodDeclaration decl)
{
- if (( decl != null
- && decl.ignoreFurtherInvestigation)
+ if ( decl.ignoreFurtherInvestigation
|| method == null
|| method.isSynthetic()) // don't wrap role field accessors
return;
@@ -737,7 +736,7 @@
parameters[i] = maybeWrapSignatureType(parameters[i], decl.scope, argument, defaultAnchor);
// in case resolveTypesFor already created the binding,
// update its type:
- if (argument.binding != null)
+ if (argument != null && argument.binding != null)
argument.binding.type = parameters[i];
}
doingSignatures = false;
@@ -839,99 +838,97 @@
*/
public static ITeamAnchor getAnchorVariableBinding(
ReferenceBinding site,
- Expression anchorExpr,
+/*nonnull*/ Expression anchorExpr,
ReferenceBinding roleType,
ProblemReporter problemReporter,
ASTNode typedNode)
{
ITeamAnchor anchorBinding = null;
- if (anchorExpr != null)
- {
- // unwrap meaningless cast:
- if (anchorExpr instanceof CastExpression) {
- CastExpression cast = (CastExpression)anchorExpr;
- if (RoleTypeBinding.isRoleWithExplicitAnchor(cast.resolvedType))
- anchorBinding = ((RoleTypeBinding)cast.resolvedType)._teamAnchor;
- else
- anchorExpr = ((CastExpression)anchorExpr).expression;
+ // unwrap meaningless cast:
+ if (anchorExpr instanceof CastExpression) {
+ CastExpression cast = (CastExpression)anchorExpr;
+ if (RoleTypeBinding.isRoleWithExplicitAnchor(cast.resolvedType))
+ anchorBinding = ((RoleTypeBinding)cast.resolvedType)._teamAnchor;
+ else
+ anchorExpr = ((CastExpression)anchorExpr).expression;
+ }
+
+ if (anchorExpr instanceof PotentialLowerExpression)
+ anchorExpr = ((PotentialLowerExpression)anchorExpr).expression;
+ if (anchorExpr instanceof ThisReference)
+ {
+ ReferenceBinding teamBinding = (ReferenceBinding)anchorExpr.resolvedType;
+ ReferenceBinding enclosingTeam = TeamModel.findEnclosingTeamContainingRole(teamBinding, roleType);
+ if (enclosingTeam == null) {
+ if ((problemReporter != null)) {
+ ASTNode location = anchorExpr;
+ if (location.sourceEnd == 0)
+ location = typedNode;
+ problemReporter.typeAnchorNotEnclosingTeam(
+ location, teamBinding, roleType);
+ }
+ return null;
+ }
+ anchorBinding = TThisBinding.getTThisForRole(roleType, enclosingTeam);
+ if (anchorBinding == null)
+ return cannotWrapType(roleType, problemReporter, typedNode);
+ } else {
+ // extract the name reference from a type anchor reference used as expression:
+ if ( anchorExpr instanceof TypeAnchorReference
+ && ((TypeAnchorReference)anchorExpr).isExpression)
+ {
+ anchorExpr = ((TypeAnchorReference)anchorExpr).anchor;
}
- if (anchorExpr instanceof PotentialLowerExpression)
- anchorExpr = ((PotentialLowerExpression)anchorExpr).expression;
- if (anchorExpr instanceof ThisReference)
- {
- ReferenceBinding teamBinding = (ReferenceBinding)anchorExpr.resolvedType;
- ReferenceBinding enclosingTeam = TeamModel.findEnclosingTeamContainingRole(teamBinding, roleType);
- if (enclosingTeam == null) {
- if ((problemReporter != null)) {
- ASTNode location = anchorExpr;
- if (location.sourceEnd == 0)
- location = typedNode;
- problemReporter.typeAnchorNotEnclosingTeam(
- location, teamBinding, roleType);
- }
- return null;
- }
- anchorBinding = TThisBinding.getTThisForRole(roleType, enclosingTeam);
- if (anchorBinding == null)
- return cannotWrapType(roleType, problemReporter, typedNode);
- } else {
- // extract the name reference from a type anchor reference used as expression:
- if ( anchorExpr instanceof TypeAnchorReference
- && ((TypeAnchorReference)anchorExpr).isExpression)
- {
- anchorExpr = ((TypeAnchorReference)anchorExpr).anchor;
- }
+ if (anchorExpr instanceof ArrayReference)
+ anchorExpr = ((ArrayReference)anchorExpr).receiver;
- if (anchorExpr instanceof ArrayReference)
- anchorExpr = ((ArrayReference)anchorExpr).receiver;
-
- if (anchorExpr instanceof FieldReference)
- {
- anchorBinding = ((Reference)anchorExpr).fieldBinding();
- }
- else if (anchorExpr.isTypeReference())
- {
- anchorBinding = null; // not an instance: not usable.
- ReferenceBinding teamBinding = TeamModel.findEnclosingTeamContainingRole(site, roleType);
- if (teamBinding == null) {
- if ((problemReporter != null))
- problemReporter.
- missingTypeAnchor(anchorExpr, roleType);
- return null;
- }
- anchorBinding = TThisBinding.getTThisForRole(roleType, teamBinding);
- if (anchorBinding == null) {
- if ((problemReporter != null))
- problemReporter.
- typeAnchorIsNotAVariable(anchorExpr, roleType.sourceName());
- return null;
- }
- }
- else if (anchorExpr instanceof NameReference)
- {
- if (anchorExpr instanceof QualifiedNameReference) {
- QualifiedNameReference qRef = (QualifiedNameReference)anchorExpr;
- anchorBinding = getAnchorFromQualifiedReceiver(
- site,
- roleType,
- (VariableBinding)qRef.binding,
- qRef.otherBindings,
- /*mergePaths*/false,
- problemReporter,
- anchorExpr,
- qRef.sourcePositions);
- if (anchorBinding == null)
- return RoleTypeBinding.NoAnchor; // already reported
- } else {
- if (((NameReference)anchorExpr).binding instanceof VariableBinding) {
- anchorBinding = (ITeamAnchor)((NameReference)anchorExpr).binding;
- if (roleType.isTypeVariable()) {
- ITeamAnchor[] anchors = ((TypeVariableBinding)roleType).anchors;
- if (anchors != null)
- return anchorBinding; // avoid analysis which requires knowledge about the role type
- }
+ if (anchorExpr instanceof FieldReference)
+ {
+ anchorBinding = ((Reference)anchorExpr).fieldBinding();
+ }
+ else if (anchorExpr.isTypeReference())
+ {
+ anchorBinding = null; // not an instance: not usable.
+ ReferenceBinding teamBinding = TeamModel.findEnclosingTeamContainingRole(site, roleType);
+ if (teamBinding == null) {
+ if ((problemReporter != null))
+ problemReporter.
+ missingTypeAnchor(anchorExpr, roleType);
+ return null;
+ }
+ anchorBinding = TThisBinding.getTThisForRole(roleType, teamBinding);
+ if (anchorBinding == null) {
+ if ((problemReporter != null))
+ problemReporter.
+ typeAnchorIsNotAVariable(anchorExpr, roleType.sourceName());
+ return null;
+ }
+ }
+ else if (anchorExpr instanceof NameReference)
+ {
+ if (anchorExpr instanceof QualifiedNameReference) {
+ QualifiedNameReference qRef = (QualifiedNameReference)anchorExpr;
+ anchorBinding = getAnchorFromQualifiedReceiver(
+ site,
+ roleType,
+ (VariableBinding)qRef.binding,
+ qRef.otherBindings,
+ /*mergePaths*/false,
+ problemReporter,
+ anchorExpr,
+ qRef.sourcePositions);
+ if (anchorBinding == null)
+ return RoleTypeBinding.NoAnchor; // already reported
+ } else {
+ if (((NameReference)anchorExpr).binding instanceof VariableBinding) {
+ anchorBinding = (ITeamAnchor)((NameReference)anchorExpr).binding;
+ if (roleType.isTypeVariable()) {
+ ITeamAnchor[] anchors = ((TypeVariableBinding)roleType).anchors;
+ if (anchors != null)
+ return anchorBinding; // avoid analysis which requires knowledge about the role type
+ }
// FIXME(SH): manual resolving of base-anchor?
// if (CharOperation.equals(((SingleNameReference)anchorExpr).token, IOTConstants._OT_BASE))
@@ -943,59 +940,58 @@
// ((FieldBinding)anchorBinding).type = site.baseclass();
// }
// }
- } else {
- if ((problemReporter != null))
- problemReporter.typeAnchorIsNotAVariable(anchorExpr, roleType.sourceName());
- return null;
- }
- }
- }
- else if (anchorExpr instanceof QualifiedAllocationExpression)
- {
- // propagate anchor from resolved type:
- QualifiedAllocationExpression allocation = (QualifiedAllocationExpression)anchorExpr;
- return ((RoleTypeBinding)allocation.resolvedType)._teamAnchor;
- }
- else if (anchorExpr instanceof MessageSend)
- {
- TypeBinding receiverLeaf = ((MessageSend)anchorExpr).actualReceiverType.leafComponentType();
- if (RoleTypeBinding.isRoleWithExplicitAnchor(receiverLeaf)) {
- anchorBinding = ((RoleTypeBinding)receiverLeaf)._teamAnchor;
- } else {
- // regression fix during work on https://bugs.eclipse.org/331877
- if (RoleTypeBinding.isRoleType(anchorExpr.resolvedType))
- return ((DependentTypeBinding)anchorExpr.resolvedType)._teamAnchor;
- return cannotWrapType(roleType, problemReporter, typedNode);
- }
- }
- else if (anchorExpr instanceof AllocationExpression)
- {
- // this anchor matches nothing
- String displayName = "fresh-instance-of-"+((AllocationExpression)anchorExpr).type.toString(); //$NON-NLS-1$
- LocalVariableBinding fakeVariable = new LocalVariableBinding(displayName.toCharArray(), roleType.enclosingType(), ClassFileConstants.AccFinal, false);
- fakeVariable.tagBits |= TagBits.IsFreshTeamInstance;
- return fakeVariable;
- }
- else if (anchorBinding == null)
- {
- return cannotWrapType(roleType, problemReporter, typedNode);
- }
- /*
- * anchorBinding = non-null
- * FieldReference
- * NameReference
- * isTypeReference() -> TThisBinding
- */
- assert (anchorBinding != null);
- }
- /*
- * variableBinding = non-null, anchorType = non-null:
- * ThisReference
- * + all others that did not already quit with an error.
- */
- // if ((problemReporter != null))
- // assert anchorBinding != null; // redundant
- }
+ } else {
+ if ((problemReporter != null))
+ problemReporter.typeAnchorIsNotAVariable(anchorExpr, roleType.sourceName());
+ return null;
+ }
+ }
+ }
+ else if (anchorExpr instanceof QualifiedAllocationExpression)
+ {
+ // propagate anchor from resolved type:
+ QualifiedAllocationExpression allocation = (QualifiedAllocationExpression)anchorExpr;
+ return ((RoleTypeBinding)allocation.resolvedType)._teamAnchor;
+ }
+ else if (anchorExpr instanceof MessageSend)
+ {
+ TypeBinding receiverLeaf = ((MessageSend)anchorExpr).actualReceiverType.leafComponentType();
+ if (RoleTypeBinding.isRoleWithExplicitAnchor(receiverLeaf)) {
+ anchorBinding = ((RoleTypeBinding)receiverLeaf)._teamAnchor;
+ } else {
+ // regression fix during work on https://bugs.eclipse.org/331877
+ if (RoleTypeBinding.isRoleType(anchorExpr.resolvedType))
+ return ((DependentTypeBinding)anchorExpr.resolvedType)._teamAnchor;
+ return cannotWrapType(roleType, problemReporter, typedNode);
+ }
+ }
+ else if (anchorExpr instanceof AllocationExpression)
+ {
+ // this anchor matches nothing
+ String displayName = "fresh-instance-of-"+((AllocationExpression)anchorExpr).type.toString(); //$NON-NLS-1$
+ LocalVariableBinding fakeVariable = new LocalVariableBinding(displayName.toCharArray(), roleType.enclosingType(), ClassFileConstants.AccFinal, false);
+ fakeVariable.tagBits |= TagBits.IsFreshTeamInstance;
+ return fakeVariable;
+ }
+ else if (anchorBinding == null)
+ {
+ return cannotWrapType(roleType, problemReporter, typedNode);
+ }
+ /*
+ * anchorBinding = non-null
+ * FieldReference
+ * NameReference
+ * isTypeReference() -> TThisBinding
+ */
+ assert (anchorBinding != null);
+ }
+ /*
+ * variableBinding = non-null, anchorType = non-null:
+ * ThisReference
+ * + all others that did not already quit with an error.
+ */
+ // if ((problemReporter != null))
+ // assert anchorBinding != null; // redundant
if (!anchorBinding.isTeamContainingRole(roleType))
{
anchorBinding = anchorBinding.retrieveAnchorFromAnchorRoleTypeFor(roleType);