package org.eclipse.jdt.internal.compiler.lookup;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.ast.*;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
public class MethodScope extends BlockScope {
public ReferenceContext referenceContext;
public boolean isStatic;
public boolean isConstructorCall = false;
public FieldBinding initializedField;
public int lastVisibleFieldID = -1;
public int analysisIndex;
public boolean isPropagatingInnerClassEmulation;
public int lastIndex = 0;
public long[] definiteInits = new long[4];
public long[][] = new long[4][];
public SyntheticArgumentBinding[] ;
public boolean hasMissingSwitchDefault;
public MethodScope(Scope parent, ReferenceContext context, boolean isStatic) {
super(METHOD_SCOPE, parent);
this.locals = new LocalVariableBinding[5];
this.referenceContext = context;
this.isStatic = isStatic;
this.startIndex = 0;
}
public MethodScope(Scope parent, ReferenceContext context, boolean isStatic, int lastVisibleFieldID) {
this(parent, context, isStatic);
this.lastVisibleFieldID = lastVisibleFieldID;
}
@Override
String basicToString(int tab) {
String newLine = "\n";
for (int i = tab; --i >= 0;)
newLine += "\t";
String s = newLine + "--- Method Scope ---";
newLine += "\t";
s += newLine + "locals:";
for (int i = 0; i < this.localIndex; i++)
s += newLine + "\t" + this.locals[i].toString();
s += newLine + "startIndex = " + this.startIndex;
s += newLine + "isConstructorCall = " + this.isConstructorCall;
s += newLine + "initializedField = " + this.initializedField;
s += newLine + "lastVisibleFieldID = " + this.lastVisibleFieldID;
s += newLine + "referenceContext = " + this.referenceContext;
return s;
}
private void checkAndSetModifiersForConstructor(MethodBinding methodBinding) {
int modifiers = methodBinding.modifiers;
final ReferenceBinding declaringClass = methodBinding.declaringClass;
if ((modifiers & ExtraCompilerModifiers.AccAlternateModifierProblem) != 0)
problemReporter().duplicateModifierForMethod(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
if ((((ConstructorDeclaration) this.referenceContext).bits & ASTNode.IsDefaultConstructor) != 0) {
final int DECLARING_FLAGS = ClassFileConstants.AccEnum|ClassFileConstants.AccPublic|ClassFileConstants.AccProtected;
final int VISIBILITY_FLAGS = ClassFileConstants.AccPrivate|ClassFileConstants.AccPublic|ClassFileConstants.AccProtected;
int flags;
if ((flags = declaringClass.modifiers & DECLARING_FLAGS) != 0) {
if ((flags & ClassFileConstants.AccEnum) != 0) {
modifiers &= ~VISIBILITY_FLAGS;
modifiers |= ClassFileConstants.AccPrivate;
} else {
modifiers &= ~VISIBILITY_FLAGS;
modifiers |= flags;
}
}
}
int realModifiers = modifiers & ExtraCompilerModifiers.AccJustFlag;
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected | ClassFileConstants.AccStrictfp);
if (declaringClass.isEnum() && (((ConstructorDeclaration) this.referenceContext).bits & ASTNode.IsDefaultConstructor) == 0) {
final int UNEXPECTED_ENUM_CONSTR_MODIFIERS = ~(ClassFileConstants.AccPrivate | ClassFileConstants.AccStrictfp);
if ((realModifiers & UNEXPECTED_ENUM_CONSTR_MODIFIERS) != 0) {
problemReporter().illegalModifierForEnumConstructor((AbstractMethodDeclaration) this.referenceContext);
modifiers &= ~ExtraCompilerModifiers.AccJustFlag | ~UNEXPECTED_ENUM_CONSTR_MODIFIERS;
} else if ((((AbstractMethodDeclaration) this.referenceContext).modifiers & ClassFileConstants.AccStrictfp) != 0) {
problemReporter().illegalModifierForMethod((AbstractMethodDeclaration) this.referenceContext);
}
modifiers |= ClassFileConstants.AccPrivate;
} else if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
problemReporter().illegalModifierForMethod((AbstractMethodDeclaration) this.referenceContext);
modifiers &= ~ExtraCompilerModifiers.AccJustFlag | ~UNEXPECTED_MODIFIERS;
} else if ((((AbstractMethodDeclaration) this.referenceContext).modifiers & ClassFileConstants.AccStrictfp) != 0) {
problemReporter().illegalModifierForMethod((AbstractMethodDeclaration) this.referenceContext);
}
int accessorBits = realModifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccProtected | ClassFileConstants.AccPrivate);
if ((accessorBits & (accessorBits - 1)) != 0) {
problemReporter().illegalVisibilityModifierCombinationForMethod(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
if ((accessorBits & ClassFileConstants.AccPublic) != 0) {
if ((accessorBits & ClassFileConstants.AccProtected) != 0)
modifiers &= ~ClassFileConstants.AccProtected;
if ((accessorBits & ClassFileConstants.AccPrivate) != 0)
modifiers &= ~ClassFileConstants.AccPrivate;
} else if ((accessorBits & ClassFileConstants.AccProtected) != 0 && (accessorBits & ClassFileConstants.AccPrivate) != 0) {
modifiers &= ~ClassFileConstants.AccPrivate;
}
}
methodBinding.modifiers = modifiers;
}
private void checkAndSetModifiersForMethod(MethodBinding methodBinding) {
int modifiers = methodBinding.modifiers;
final ReferenceBinding declaringClass = methodBinding.declaringClass;
if ((modifiers & ExtraCompilerModifiers.AccAlternateModifierProblem) != 0)
problemReporter().duplicateModifierForMethod(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
int realModifiers = modifiers & ExtraCompilerModifiers.AccJustFlag;
long sourceLevel = compilerOptions().sourceLevel;
if (declaringClass.isInterface()) {
int expectedModifiers = ClassFileConstants.AccPublic | ClassFileConstants.AccAbstract;
boolean isDefaultMethod = (modifiers & ExtraCompilerModifiers.AccDefaultMethod) != 0;
boolean reportIllegalModifierCombination = false;
if (sourceLevel >= ClassFileConstants.JDK1_8 && !declaringClass.isAnnotationType()) {
expectedModifiers |= ClassFileConstants.AccStrictfp
| ExtraCompilerModifiers.AccDefaultMethod | ClassFileConstants.AccStatic;
expectedModifiers |= sourceLevel >= ClassFileConstants.JDK9 ? ClassFileConstants.AccPrivate : 0;
if (!methodBinding.isAbstract()) {
reportIllegalModifierCombination = isDefaultMethod && methodBinding.isStatic();
} else {
reportIllegalModifierCombination = isDefaultMethod || methodBinding.isStatic();
if (methodBinding.isStrictfp()) {
problemReporter().illegalAbstractModifierCombinationForMethod((AbstractMethodDeclaration) this.referenceContext);
}
}
if (reportIllegalModifierCombination) {
problemReporter().illegalModifierCombinationForInterfaceMethod((AbstractMethodDeclaration) this.referenceContext);
}
if (sourceLevel >= ClassFileConstants.JDK9 && (methodBinding.modifiers & ClassFileConstants.AccPrivate) != 0) {
int remaining = realModifiers & ~expectedModifiers;
if (remaining == 0) {
remaining = realModifiers & ~(ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic | ClassFileConstants.AccStrictfp);
if (isDefaultMethod || remaining != 0)
problemReporter().illegalModifierCombinationForPrivateInterfaceMethod((AbstractMethodDeclaration) this.referenceContext);
}
}
if (isDefaultMethod) {
realModifiers |= ExtraCompilerModifiers.AccDefaultMethod;
}
}
if ((realModifiers & ~expectedModifiers) != 0) {
if ((declaringClass.modifiers & ClassFileConstants.AccAnnotation) != 0)
problemReporter().illegalModifierForAnnotationMember((AbstractMethodDeclaration) this.referenceContext);
else
problemReporter().illegalModifierForInterfaceMethod((AbstractMethodDeclaration) this.referenceContext, sourceLevel);
methodBinding.modifiers &= (expectedModifiers | ~ExtraCompilerModifiers.AccJustFlag);
}
return;
} else if (declaringClass.isAnonymousType() && sourceLevel >= ClassFileConstants.JDK9) {
LocalTypeBinding local = (LocalTypeBinding) declaringClass;
TypeReference ref = local.scope.referenceContext.allocation.type;
if (ref != null && (ref.bits & ASTNode.IsDiamond) != 0) {
if ((realModifiers & (ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic )) == 0) {
methodBinding.tagBits |= TagBits.AnnotationOverride;
}
}
}
final int UNEXPECTED_MODIFIERS = ~(ClassFileConstants.AccPublic | ClassFileConstants.AccPrivate | ClassFileConstants.AccProtected
| ClassFileConstants.AccAbstract | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal | ClassFileConstants.AccSynchronized | ClassFileConstants.AccNative | ClassFileConstants.AccStrictfp);
if ((realModifiers & UNEXPECTED_MODIFIERS) != 0) {
problemReporter().illegalModifierForMethod((AbstractMethodDeclaration) this.referenceContext);
modifiers &= ~ExtraCompilerModifiers.AccJustFlag | ~UNEXPECTED_MODIFIERS;
}
int accessorBits = realModifiers & (ClassFileConstants.AccPublic | ClassFileConstants.AccProtected | ClassFileConstants.AccPrivate);
if ((accessorBits & (accessorBits - 1)) != 0) {
problemReporter().illegalVisibilityModifierCombinationForMethod(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
if ((accessorBits & ClassFileConstants.AccPublic) != 0) {
if ((accessorBits & ClassFileConstants.AccProtected) != 0)
modifiers &= ~ClassFileConstants.AccProtected;
if ((accessorBits & ClassFileConstants.AccPrivate) != 0)
modifiers &= ~ClassFileConstants.AccPrivate;
} else if ((accessorBits & ClassFileConstants.AccProtected) != 0 && (accessorBits & ClassFileConstants.AccPrivate) != 0) {
modifiers &= ~ClassFileConstants.AccPrivate;
}
}
if ((modifiers & ClassFileConstants.AccAbstract) != 0) {
int incompatibleWithAbstract = ClassFileConstants.AccPrivate | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal | ClassFileConstants.AccSynchronized | ClassFileConstants.AccNative | ClassFileConstants.AccStrictfp;
if ((modifiers & incompatibleWithAbstract) != 0)
problemReporter().illegalAbstractModifierCombinationForMethod(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
if (!methodBinding.declaringClass.isAbstract())
problemReporter().abstractMethodInAbstractClass((SourceTypeBinding) declaringClass, (AbstractMethodDeclaration) this.referenceContext);
}
if ((modifiers & ClassFileConstants.AccNative) != 0 && (modifiers & ClassFileConstants.AccStrictfp) != 0)
problemReporter().nativeMethodsCannotBeStrictfp(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
if (((realModifiers & ClassFileConstants.AccStatic) != 0) && declaringClass.isNestedType() && !declaringClass.isStatic())
problemReporter().unexpectedStaticModifierForMethod(declaringClass, (AbstractMethodDeclaration) this.referenceContext);
methodBinding.modifiers = modifiers;
}
public void checkUnusedParameters(MethodBinding method) {
if (method.isAbstract()
|| (method.isImplementing() && !compilerOptions().reportUnusedParameterWhenImplementingAbstract)
|| (method.isOverriding() && !method.isImplementing() && !compilerOptions().reportUnusedParameterWhenOverridingConcrete)
|| method.isMain()) {
return;
}
for (int i = 0, maxLocals = this.localIndex; i < maxLocals; i++) {
LocalVariableBinding local = this.locals[i];
if (local == null || ((local.tagBits & TagBits.IsArgument) == 0)) {
break;
}
if (local.useFlag == LocalVariableBinding.UNUSED &&
((local.declaration.bits & ASTNode.IsLocalDeclarationReachable) != 0)) {
problemReporter().unusedArgument(local.declaration);
}
}
}
public void computeLocalVariablePositions(int initOffset, CodeStream codeStream) {
this.offset = initOffset;
this.maxOffset = initOffset;
int ilocal = 0, maxLocals = this.localIndex;
while (ilocal < maxLocals) {
LocalVariableBinding local = this.locals[ilocal];
if (local == null || ((local.tagBits & TagBits.IsArgument) == 0)) break;
codeStream.record(local);
local.resolvedPosition = this.offset;
if ((TypeBinding.equalsEquals(local.type, TypeBinding.LONG)) || (TypeBinding.equalsEquals(local.type, TypeBinding.DOUBLE))) {
this.offset += 2;
} else {
this.offset++;
}
if (this.offset > 0xFF) {
problemReporter().noMoreAvailableSpaceForArgument(local, local.declaration);
}
ilocal++;
}
if (this.extraSyntheticArguments != null) {
for (int iarg = 0, maxArguments = this.extraSyntheticArguments.length; iarg < maxArguments; iarg++){
SyntheticArgumentBinding argument = this.extraSyntheticArguments[iarg];
argument.resolvedPosition = this.offset;
if ((TypeBinding.equalsEquals(argument.type, TypeBinding.LONG)) || (TypeBinding.equalsEquals(argument.type, TypeBinding.DOUBLE))){
this.offset += 2;
} else {
this.offset++;
}
if (this.offset > 0xFF) {
problemReporter().noMoreAvailableSpaceForArgument(argument, (ASTNode)this.referenceContext);
}
}
}
this.computeLocalVariablePositions(ilocal, this.offset, codeStream);
}
MethodBinding createMethod(AbstractMethodDeclaration method) {
this.referenceContext = method;
method.scope = this;
long sourceLevel = compilerOptions().sourceLevel;
SourceTypeBinding declaringClass = referenceType().binding;
int modifiers = method.modifiers | ExtraCompilerModifiers.AccUnresolved;
if (method.isConstructor()) {
if (method.isDefaultConstructor())
modifiers |= ExtraCompilerModifiers.AccIsDefaultConstructor;
method.binding = new MethodBinding(modifiers, null, null, declaringClass);
checkAndSetModifiersForConstructor(method.binding);
} else {
if (declaringClass.isInterface()) {
if (sourceLevel >= ClassFileConstants.JDK9 && ((method.modifiers & ClassFileConstants.AccPrivate) != 0)) {
} else if (method.isDefaultMethod() || method.isStatic()) {
modifiers |= ClassFileConstants.AccPublic;
} else {
modifiers |= ClassFileConstants.AccPublic | ClassFileConstants.AccAbstract;
}
}
method.binding =
new MethodBinding(modifiers, method.selector, null, null, null, declaringClass);
checkAndSetModifiersForMethod(method.binding);
}
this.isStatic = method.binding.isStatic();
Argument[] argTypes = method.arguments;
int argLength = argTypes == null ? 0 : argTypes.length;
if (argLength > 0) {
Argument argument = argTypes[--argLength];
if (argument.isVarArgs() && sourceLevel >= ClassFileConstants.JDK1_5)
method.binding.modifiers |= ClassFileConstants.AccVarargs;
if (CharOperation.equals(argument.name, ConstantPool.This)) {
problemReporter().illegalThisDeclaration(argument);
}
while (--argLength >= 0) {
argument = argTypes[argLength];
if (argument.isVarArgs() && sourceLevel >= ClassFileConstants.JDK1_5)
problemReporter().illegalVararg(argument, method);
if (CharOperation.equals(argument.name, ConstantPool.This)) {
problemReporter().illegalThisDeclaration(argument);
}
}
}
if (method.receiver != null) {
if (sourceLevel <= ClassFileConstants.JDK1_7) {
problemReporter().illegalSourceLevelForThis(method.receiver);
}
if (method.receiver.annotations != null) {
method.bits |= ASTNode.HasTypeAnnotations;
}
}
TypeParameter[] typeParameters = method.typeParameters();
if (typeParameters == null || typeParameters.length == 0) {
method.binding.typeVariables = Binding.NO_TYPE_VARIABLES;
} else {
method.binding.typeVariables = createTypeVariables(typeParameters, method.binding);
method.binding.modifiers |= ExtraCompilerModifiers.AccGenericSignature;
}
return method.binding;
}
@Override
public FieldBinding findField(TypeBinding receiverType, char[] fieldName, InvocationSite invocationSite, boolean needResolve) {
FieldBinding field = super.findField(receiverType, fieldName, invocationSite, needResolve);
if (field == null)
return null;
if (!field.isValidBinding())
return field;
if (receiverType.isInterface() && invocationSite.isQualifiedSuper())
return new ProblemFieldBinding(
field,
field.declaringClass,
fieldName,
ProblemReasons.NoProperEnclosingInstance);
if (field.isStatic())
return field;
if (!this.isConstructorCall || TypeBinding.notEquals(receiverType, enclosingSourceType()))
return field;
if (invocationSite instanceof SingleNameReference)
return new ProblemFieldBinding(
field,
field.declaringClass,
fieldName,
ProblemReasons.NonStaticReferenceInConstructorInvocation);
if (invocationSite instanceof QualifiedNameReference) {
QualifiedNameReference name = (QualifiedNameReference) invocationSite;
if (name.binding == null)
return new ProblemFieldBinding(
field,
field.declaringClass,
fieldName,
ProblemReasons.NonStaticReferenceInConstructorInvocation);
}
return field;
}
public boolean isInsideConstructor() {
return (this.referenceContext instanceof ConstructorDeclaration);
}
public boolean isInsideInitializer() {
return (this.referenceContext instanceof TypeDeclaration);
}
@Override
public boolean isLambdaScope() {
return this.referenceContext instanceof LambdaExpression;
}
public boolean isInsideInitializerOrConstructor() {
return (this.referenceContext instanceof TypeDeclaration)
|| (this.referenceContext instanceof ConstructorDeclaration);
}
@Override
public ProblemReporter problemReporter() {
ProblemReporter problemReporter = referenceCompilationUnit().problemReporter;
problemReporter.referenceContext = this.referenceContext;
return problemReporter;
}
public final int recordInitializationStates(FlowInfo flowInfo) {
if ((flowInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0) return -1;
UnconditionalFlowInfo unconditionalFlowInfo = flowInfo.unconditionalInitsWithoutSideEffect();
long[] extraInits = unconditionalFlowInfo.extra == null ?
null : unconditionalFlowInfo.extra[0];
long inits = unconditionalFlowInfo.definiteInits;
checkNextEntry : for (int i = this.lastIndex; --i >= 0;) {
if (this.definiteInits[i] == inits) {
long[] otherInits = this.extraDefiniteInits[i];
if ((extraInits != null) && (otherInits != null)) {
if (extraInits.length == otherInits.length) {
int j, max;
for (j = 0, max = extraInits.length; j < max; j++) {
if (extraInits[j] != otherInits[j]) {
continue checkNextEntry;
}
}
return i;
}
} else {
if ((extraInits == null) && (otherInits == null)) {
return i;
}
}
}
}
if (this.definiteInits.length == this.lastIndex) {
System.arraycopy(
this.definiteInits,
0,
(this.definiteInits = new long[this.lastIndex + 20]),
0,
this.lastIndex);
System.arraycopy(
this.extraDefiniteInits,
0,
(this.extraDefiniteInits = new long[this.lastIndex + 20][]),
0,
this.lastIndex);
}
this.definiteInits[this.lastIndex] = inits;
if (extraInits != null) {
this.extraDefiniteInits[this.lastIndex] = new long[extraInits.length];
System.arraycopy(
extraInits,
0,
this.extraDefiniteInits[this.lastIndex],
0,
extraInits.length);
}
return this.lastIndex++;
}
public AbstractMethodDeclaration referenceMethod() {
if (this.referenceContext instanceof AbstractMethodDeclaration) return (AbstractMethodDeclaration) this.referenceContext;
return null;
}
public MethodBinding referenceMethodBinding() {
if (this.referenceContext instanceof LambdaExpression)
return ((LambdaExpression)this.referenceContext).binding;
if (this.referenceContext instanceof AbstractMethodDeclaration)
return ((AbstractMethodDeclaration)this.referenceContext).binding;
return null;
}
@Override
public TypeDeclaration referenceType() {
ClassScope scope = enclosingClassScope();
return scope == null ? null : scope.referenceContext;
}
@Override
void resolveTypeParameter(TypeParameter typeParameter) {
typeParameter.resolve(this);
}
@Override
public boolean hasDefaultNullnessFor(int location, int sourceStart) {
int nonNullByDefaultValue = localNonNullByDefaultValue(sourceStart);
if(nonNullByDefaultValue != 0) {
return (nonNullByDefaultValue & location) != 0;
}
AbstractMethodDeclaration referenceMethod = referenceMethod();
if (referenceMethod != null) {
MethodBinding binding = referenceMethod.binding;
if (binding != null && binding.defaultNullness != 0) {
return (binding.defaultNullness & location) != 0;
}
}
return this.parent.hasDefaultNullnessFor(location, sourceStart);
}
@Override
public Binding checkRedundantDefaultNullness(int nullBits, int sourceStart) {
Binding target = localCheckRedundantDefaultNullness(nullBits, sourceStart);
if (target != null) {
return target;
}
AbstractMethodDeclaration referenceMethod = referenceMethod();
if (referenceMethod != null) {
MethodBinding binding = referenceMethod.binding;
if (binding != null && binding.defaultNullness != 0) {
return (binding.defaultNullness == nullBits) ? binding : null;
}
}
return this.parent.checkRedundantDefaultNullness(nullBits, sourceStart);
}
public boolean shouldCheckAPILeaks(ReferenceBinding declaringClass, boolean memberIsPublic) {
if (environment().useModuleSystem)
return memberIsPublic && declaringClass.isPublic() && declaringClass.fPackage.isExported();
return false;
}
public void detectAPILeaks(ASTNode typeNode, TypeBinding type) {
if (environment().useModuleSystem) {
ASTVisitor visitor = new ASTVisitor() {
@Override
public boolean visit(SingleTypeReference typeReference, BlockScope scope) {
if (typeReference.resolvedType instanceof ReferenceBinding)
checkType((ReferenceBinding) typeReference.resolvedType, typeReference.sourceStart, typeReference.sourceEnd);
return true;
}
@Override
public boolean visit(QualifiedTypeReference typeReference, BlockScope scope) {
if (typeReference.resolvedType instanceof ReferenceBinding)
checkType((ReferenceBinding) typeReference.resolvedType, typeReference.sourceStart, typeReference.sourceEnd);
return true;
}
@Override
public boolean visit(ArrayTypeReference typeReference, BlockScope scope) {
TypeBinding leafComponentType = typeReference.resolvedType.leafComponentType();
if (leafComponentType instanceof ReferenceBinding)
checkType((ReferenceBinding) leafComponentType, typeReference.sourceStart, typeReference.originalSourceEnd);
return true;
}
private void checkType(ReferenceBinding referenceBinding, int sourceStart, int sourceEnd) {
if (!referenceBinding.isValidBinding())
return;
ModuleBinding otherModule = referenceBinding.module();
if (otherModule == otherModule.environment.javaBaseModule())
return;
if (!isFullyPublic(referenceBinding)) {
problemReporter().nonPublicTypeInAPI(referenceBinding, sourceStart, sourceEnd);
} else if (!referenceBinding.fPackage.isExported()) {
problemReporter().notExportedTypeInAPI(referenceBinding, sourceStart, sourceEnd);
} else if (isUnrelatedModule(referenceBinding.fPackage)) {
problemReporter().missingRequiresTransitiveForTypeInAPI(referenceBinding, sourceStart, sourceEnd);
}
}
private boolean isFullyPublic(ReferenceBinding referenceBinding) {
if (!referenceBinding.isPublic())
return false;
if (referenceBinding instanceof NestedTypeBinding)
return isFullyPublic(((NestedTypeBinding) referenceBinding).enclosingType);
return true;
}
private boolean isUnrelatedModule(PackageBinding fPackage) {
ModuleBinding otherModule = fPackage.enclosingModule;
ModuleBinding thisModule = module();
if (thisModule != otherModule) {
return !thisModule.isTransitivelyRequired(otherModule);
}
return false;
}
};
typeNode.traverse(visitor, this);
}
}
}