List of usage examples for org.eclipse.jdt.internal.compiler.ast Wildcard SUPER
int SUPER
To view the source code for org.eclipse.jdt.internal.compiler.ast Wildcard SUPER.
Click Source Link
From source file:ch.uzh.ifi.seal.changedistiller.ast.java.JavaDeclarationConverter.java
License:Apache License
@Override public boolean visit(Wildcard type, BlockScope scope) { String bound = ""; switch (type.kind) { case Wildcard.EXTENDS: bound = "extends"; break;// w ww. jav a 2 s. c o m case Wildcard.SUPER: bound = "super"; break; default: } pushValuedNode(type, bound); return true; }
From source file:com.codenvy.ide.ext.java.server.internal.core.search.matching.PatternLocator.java
License:Open Source License
protected void updateMatch(TypeBinding[] argumentsBinding, MatchLocator locator, char[][] patternArguments, boolean hasTypeParameters) { // Only possible if locator has an unit scope. if (locator.unitScope == null) return;//from w ww . j a va 2 s . com // First compare lengthes int patternTypeArgsLength = patternArguments == null ? 0 : patternArguments.length; int typeArgumentsLength = argumentsBinding == null ? 0 : argumentsBinding.length; // Initialize match rule int matchRule = this.match.getRule(); if (this.match.isRaw()) { if (patternTypeArgsLength != 0) { matchRule &= ~SearchPattern.R_FULL_MATCH; } } if (hasTypeParameters) { matchRule = SearchPattern.R_ERASURE_MATCH; } // Compare arguments lengthes if (patternTypeArgsLength == typeArgumentsLength) { if (!this.match.isRaw() && hasTypeParameters) { // generic patterns are always not compatible match this.match.setRule(SearchPattern.R_ERASURE_MATCH); return; } } else { if (patternTypeArgsLength == 0) { if (!this.match.isRaw() || hasTypeParameters) { this.match.setRule(matchRule & ~SearchPattern.R_FULL_MATCH); } } else if (typeArgumentsLength == 0) { // raw binding is always compatible this.match.setRule(matchRule & ~SearchPattern.R_FULL_MATCH); } else { this.match.setRule(0); // impossible match } return; } if (argumentsBinding == null || patternArguments == null) { this.match.setRule(matchRule); return; } // Compare binding for each type argument only if pattern is not erasure only and at first level if (!hasTypeParameters && !this.match.isRaw() && (this.match.isEquivalent() || this.match.isExact())) { for (int i = 0; i < typeArgumentsLength; i++) { // Get parameterized type argument binding TypeBinding argumentBinding = argumentsBinding[i]; if (argumentBinding instanceof CaptureBinding) { WildcardBinding capturedWildcard = ((CaptureBinding) argumentBinding).wildcard; if (capturedWildcard != null) argumentBinding = capturedWildcard; } // Get binding for pattern argument char[] patternTypeArgument = patternArguments[i]; char patternWildcard = patternTypeArgument[0]; char[] patternTypeName = patternTypeArgument; int patternWildcardKind = -1; switch (patternWildcard) { case Signature.C_STAR: if (argumentBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; if (wildcardBinding.boundKind == Wildcard.UNBOUND) continue; } matchRule &= ~SearchPattern.R_FULL_MATCH; continue; // unbound parameter always match case Signature.C_EXTENDS: patternWildcardKind = Wildcard.EXTENDS; patternTypeName = CharOperation.subarray(patternTypeArgument, 1, patternTypeArgument.length); break; case Signature.C_SUPER: patternWildcardKind = Wildcard.SUPER; patternTypeName = CharOperation.subarray(patternTypeArgument, 1, patternTypeArgument.length); break; default: break; } patternTypeName = Signature.toCharArray(patternTypeName); TypeBinding patternBinding = locator.getType(patternTypeArgument, patternTypeName); // If have no binding for pattern arg, then we won't be able to refine accuracy if (patternBinding == null) { if (argumentBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; if (wildcardBinding.boundKind == Wildcard.UNBOUND) { matchRule &= ~SearchPattern.R_FULL_MATCH; } else { this.match.setRule(SearchPattern.R_ERASURE_MATCH); return; } } continue; } // Verify tha pattern binding is compatible with match type argument binding switch (patternWildcard) { case Signature.C_STAR: // UNBOUND pattern // unbound always match => skip to next argument matchRule &= ~SearchPattern.R_FULL_MATCH; continue; case Signature.C_EXTENDS: // EXTENDS pattern if (argumentBinding.isWildcard()) { // argument is a wildcard WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; // It's ok if wildcards are identical if (wildcardBinding.boundKind == patternWildcardKind && wildcardBinding.bound == patternBinding) { continue; } // Look for wildcard compatibility switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: if (wildcardBinding.bound == null || wildcardBinding.bound.isCompatibleWith(patternBinding)) { // valid when arg extends a subclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.SUPER: break; case Wildcard.UNBOUND: matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } } else if (argumentBinding.isCompatibleWith(patternBinding)) { // valid when arg is a subclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Signature.C_SUPER: // SUPER pattern if (argumentBinding.isWildcard()) { // argument is a wildcard WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; // It's ok if wildcards are identical if (wildcardBinding.boundKind == patternWildcardKind && wildcardBinding.bound == patternBinding) { continue; } // Look for wildcard compatibility switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: break; case Wildcard.SUPER: if (wildcardBinding.bound == null || patternBinding.isCompatibleWith(wildcardBinding.bound)) { // valid only when arg super a superclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.UNBOUND: matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } } else if (patternBinding.isCompatibleWith(argumentBinding)) { // valid only when arg is a superclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; default: if (argumentBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: if (wildcardBinding.bound == null || patternBinding.isCompatibleWith(wildcardBinding.bound)) { // valid only when arg extends a superclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.SUPER: if (wildcardBinding.bound == null || wildcardBinding.bound.isCompatibleWith(patternBinding)) { // valid only when arg super a subclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.UNBOUND: matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } } else if (argumentBinding == patternBinding) // valid only when arg is equals to pattern continue; break; } // Argument does not match => erasure match will be the only possible one this.match.setRule(SearchPattern.R_ERASURE_MATCH); return; } } // Set match rule this.match.setRule(matchRule); }
From source file:com.redhat.ceylon.eclipse.core.model.loader.JDTType.java
License:Open Source License
@Override public TypeMirror getLowerBound() { if (!lowerBoundSet) { if (type.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) type; if (wildcardBinding.boundKind == Wildcard.SUPER) { TypeBinding lowerBoundBinding = wildcardBinding.bound; if (lowerBoundBinding != null) { lowerBound = new JDTType(lowerBoundBinding, lookupEnvironment); }/*from ww w. j a v a 2s . c o m*/ } } lowerBoundSet = true; } return lowerBound; }
From source file:com.redhat.ceylon.eclipse.core.model.mirror.UnknownTypeMirror.java
License:Open Source License
public JDTType(TypeBinding type, IdentityHashMap<TypeBinding, JDTType> originatingTypes) { originatingTypes.put(type, this); // type params are not qualified if (type instanceof TypeVariableBinding) qualifiedName = new String(type.qualifiedSourceName()); else//www . j ava 2s . c o m qualifiedName = JDTUtils.getFullyQualifiedName(type); typeKind = findKind(type); isPrimitive = type.isBaseType() && type.id != TypeIds.T_void && type.id != TypeIds.T_null; isRaw = type.isRawType(); if (type instanceof ParameterizedTypeBinding && !(type instanceof RawTypeBinding)) { TypeBinding[] javaTypeArguments = ((ParameterizedTypeBinding) type).arguments; if (javaTypeArguments == null) { javaTypeArguments = new TypeBinding[0]; } typeArguments = new ArrayList<TypeMirror>(javaTypeArguments.length); for (TypeBinding typeArgument : javaTypeArguments) typeArguments.add(toTypeMirror(typeArgument, type, this, originatingTypes)); } else { typeArguments = Collections.emptyList(); } if (type instanceof ArrayBinding) { TypeBinding jdtComponentType = ((ArrayBinding) type).elementsType(); componentType = toTypeMirror(jdtComponentType, type, this, originatingTypes); } else { componentType = null; } if (type.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) type; if (wildcardBinding.boundKind == Wildcard.EXTENDS) { TypeBinding upperBoundBinding = wildcardBinding.bound; if (upperBoundBinding != null) { upperBound = toTypeMirror(upperBoundBinding, type, this, originatingTypes); } } } else if (type.isTypeVariable()) { TypeVariableBinding typeVariableBinding = (TypeVariableBinding) type; TypeBinding boundBinding = typeVariableBinding.firstBound; // TODO : we should confirm this if (boundBinding != null) { upperBound = toTypeMirror(boundBinding, type, this, originatingTypes); } } else { upperBound = null; } if (type.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) type; if (wildcardBinding.boundKind == Wildcard.SUPER) { TypeBinding lowerBoundBinding = wildcardBinding.bound; if (lowerBoundBinding != null) { lowerBound = toTypeMirror(lowerBoundBinding, type, this, originatingTypes); } } } if (type instanceof ParameterizedTypeBinding || type instanceof SourceTypeBinding || type instanceof BinaryTypeBinding) { ReferenceBinding refBinding = (ReferenceBinding) type; declaredClass = new JDTClass(refBinding, JDTModelLoader.toType(refBinding)); } if (type instanceof TypeVariableBinding) { typeParameter = new JDTTypeParameter((TypeVariableBinding) type, this, originatingTypes); } }
From source file:lombok.eclipse.handlers.ast.EclipseASTMaker.java
License:Open Source License
@Override public ASTNode visitWildcard(final lombok.ast.Wildcard node, final Void p) { int kind = Wildcard.UNBOUND; if (node.getBound() != null) { switch (node.getBound()) { case SUPER: kind = Wildcard.SUPER; break; default:// www.ja v a 2 s . c o m case EXTENDS: kind = Wildcard.EXTENDS; } } final Wildcard wildcard = new Wildcard(kind); setGeneratedByAndCopyPos(wildcard, source, posHintOf(node)); wildcard.bound = build(node.getType()); return wildcard; }
From source file:lombok.eclipse.handlers.EclipseHandlerUtil.java
License:Open Source License
public static TypeReference makeType(TypeBinding binding, ASTNode pos, boolean allowCompound) { int dims = binding.dimensions(); binding = binding.leafComponentType(); // Primitives char[] base = null; switch (binding.id) { case TypeIds.T_int: base = TypeConstants.INT;/*from w w w . ja v a 2 s. c o m*/ break; case TypeIds.T_long: base = TypeConstants.LONG; break; case TypeIds.T_short: base = TypeConstants.SHORT; break; case TypeIds.T_byte: base = TypeConstants.BYTE; break; case TypeIds.T_double: base = TypeConstants.DOUBLE; break; case TypeIds.T_float: base = TypeConstants.FLOAT; break; case TypeIds.T_boolean: base = TypeConstants.BOOLEAN; break; case TypeIds.T_char: base = TypeConstants.CHAR; break; case TypeIds.T_void: base = TypeConstants.VOID; break; case TypeIds.T_null: return null; } if (base != null) { if (dims > 0) { TypeReference result = new ArrayTypeReference(base, dims, pos(pos)); setGeneratedBy(result, pos); return result; } TypeReference result = new SingleTypeReference(base, pos(pos)); setGeneratedBy(result, pos); return result; } if (binding.isAnonymousType()) { ReferenceBinding ref = (ReferenceBinding) binding; ReferenceBinding[] supers = ref.superInterfaces(); if (supers == null || supers.length == 0) supers = new ReferenceBinding[] { ref.superclass() }; if (supers[0] == null) { TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3)); setGeneratedBy(result, pos); return result; } return makeType(supers[0], pos, false); } if (binding instanceof CaptureBinding) { return makeType(((CaptureBinding) binding).wildcard, pos, allowCompound); } if (binding.isUnboundWildcard()) { if (!allowCompound) { TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3)); setGeneratedBy(result, pos); return result; } else { Wildcard out = new Wildcard(Wildcard.UNBOUND); setGeneratedBy(out, pos); out.sourceStart = pos.sourceStart; out.sourceEnd = pos.sourceEnd; return out; } } if (binding.isWildcard()) { WildcardBinding wildcard = (WildcardBinding) binding; if (wildcard.boundKind == Wildcard.EXTENDS) { if (!allowCompound) { return makeType(wildcard.bound, pos, false); } else { Wildcard out = new Wildcard(Wildcard.EXTENDS); setGeneratedBy(out, pos); out.bound = makeType(wildcard.bound, pos, false); out.sourceStart = pos.sourceStart; out.sourceEnd = pos.sourceEnd; return out; } } else if (allowCompound && wildcard.boundKind == Wildcard.SUPER) { Wildcard out = new Wildcard(Wildcard.SUPER); setGeneratedBy(out, pos); out.bound = makeType(wildcard.bound, pos, false); out.sourceStart = pos.sourceStart; out.sourceEnd = pos.sourceEnd; return out; } else { TypeReference result = new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3)); setGeneratedBy(result, pos); return result; } } // Keep moving up via 'binding.enclosingType()' and gather generics from each binding. We stop after a local type, or a static type, or a top-level type. // Finally, add however many nullTypeArgument[] arrays as that are missing, inverse the list, toArray it, and use that as PTR's typeArgument argument. List<TypeReference[]> params = new ArrayList<TypeReference[]>(); /* Calculate generics */ { TypeBinding b = binding; while (true) { boolean isFinalStop = b.isLocalType() || !b.isMemberType() || b.enclosingType() == null; TypeReference[] tyParams = null; if (b instanceof ParameterizedTypeBinding) { ParameterizedTypeBinding paramized = (ParameterizedTypeBinding) b; if (paramized.arguments != null) { tyParams = new TypeReference[paramized.arguments.length]; for (int i = 0; i < tyParams.length; i++) { tyParams[i] = makeType(paramized.arguments[i], pos, true); } } } params.add(tyParams); if (isFinalStop) break; b = b.enclosingType(); } } char[][] parts; if (binding.isTypeVariable()) { parts = new char[][] { binding.shortReadableName() }; } else if (binding.isLocalType()) { parts = new char[][] { binding.sourceName() }; } else { String[] pkg = new String(binding.qualifiedPackageName()).split("\\."); String[] name = new String(binding.qualifiedSourceName()).split("\\."); if (pkg.length == 1 && pkg[0].isEmpty()) pkg = new String[0]; parts = new char[pkg.length + name.length][]; int ptr; for (ptr = 0; ptr < pkg.length; ptr++) parts[ptr] = pkg[ptr].toCharArray(); for (; ptr < pkg.length + name.length; ptr++) parts[ptr] = name[ptr - pkg.length].toCharArray(); } while (params.size() < parts.length) params.add(null); Collections.reverse(params); boolean isParamized = false; for (TypeReference[] tyParams : params) { if (tyParams != null) { isParamized = true; break; } } if (isParamized) { if (parts.length > 1) { TypeReference[][] typeArguments = params.toArray(new TypeReference[0][]); TypeReference result = new ParameterizedQualifiedTypeReference(parts, typeArguments, dims, poss(pos, parts.length)); setGeneratedBy(result, pos); return result; } TypeReference result = new ParameterizedSingleTypeReference(parts[0], params.get(0), dims, pos(pos)); setGeneratedBy(result, pos); return result; } if (dims > 0) { if (parts.length > 1) { TypeReference result = new ArrayQualifiedTypeReference(parts, dims, poss(pos, parts.length)); setGeneratedBy(result, pos); return result; } TypeReference result = new ArrayTypeReference(parts[0], dims, pos(pos)); setGeneratedBy(result, pos); return result; } if (parts.length > 1) { TypeReference result = new QualifiedTypeReference(parts, poss(pos, parts.length)); setGeneratedBy(result, pos); return result; } TypeReference result = new SingleTypeReference(parts[0], pos(pos)); setGeneratedBy(result, pos); return result; }
From source file:org.codehaus.jdt.groovy.internal.compiler.ast.GroovyCompilationUnitDeclaration.java
License:Open Source License
private TypeReference createTypeReferenceForClassNode(GenericsType genericsType) { if (genericsType.isWildcard()) { ClassNode[] bounds = genericsType.getUpperBounds(); if (bounds != null) { // FIXASC other bounds? // positions example: (29>31)Set<(33>54)? extends (43>54)Serializable> TypeReference boundReference = createTypeReferenceForClassNode(bounds[0]); Wildcard wildcard = new Wildcard(Wildcard.EXTENDS); wildcard.sourceStart = genericsType.getStart(); wildcard.sourceEnd = boundReference.sourceEnd(); wildcard.bound = boundReference; return wildcard; } else if (genericsType.getLowerBound() != null) { // positions example: (67>69)Set<(71>84)? super (79>84)Number> TypeReference boundReference = createTypeReferenceForClassNode(genericsType.getLowerBound()); Wildcard wildcard = new Wildcard(Wildcard.SUPER); wildcard.sourceStart = genericsType.getStart(); wildcard.sourceEnd = boundReference.sourceEnd(); wildcard.bound = boundReference; return wildcard; } else {/*w w w .j a v a 2 s .co m*/ Wildcard w = new Wildcard(Wildcard.UNBOUND); w.sourceStart = genericsType.getStart(); w.sourceEnd = genericsType.getStart(); return w; } // FIXASC what does the check on this next really line mean? } else if (!genericsType.getType().isGenericsPlaceHolder()) { TypeReference typeReference = createTypeReferenceForClassNode(genericsType.getType()); return typeReference; } else { // this means it is a placeholder. As an example, if the reference is to 'List' // then the genericsType info may include a placeholder for the type variable (as the user // didn't fill it in as anything) and so for this example the genericsType is 'E extends java.lang.Object' // I don't think we need a type reference for this as the type references we are constructed // here are representative of what the user did in the source, not the resolved result of that. // throw new GroovyEclipseBug(); return null; } }
From source file:org.codehaus.jdt.groovy.internal.compiler.ast.JDTClassNodeBuilder.java
License:Open Source License
private TypeBinding[] getLowerbounds(WildcardBinding wildcardType) { if (wildcardType.boundKind == Wildcard.SUPER) { return new TypeBinding[] { wildcardType.bound }; }/*from ww w . j ava 2 s . c o m*/ return TypeBinding.NO_TYPES; }
From source file:org.codehaus.jdt.groovy.internal.compiler.ast.JDTResolver.java
License:Open Source License
private ClassNode createClassNodeForWildcardBinding(WildcardBinding wildcardBinding) { // FIXASC could use LazyGenericsType object here ClassNode base = ClassHelper.makeWithoutCaching("?"); ClassNode lowerBound = null;/*from ww w .j a v a 2 s. c o m*/ ClassNode[] allUppers = null; if (wildcardBinding.boundKind == Wildcard.EXTENDS) { ClassNode firstUpper = convertToClassNode(wildcardBinding.bound); ClassNode[] otherUppers = (wildcardBinding.otherBounds == null ? null : convertToClassNodes(wildcardBinding.otherBounds)); if (otherUppers == null) { allUppers = new ClassNode[] { firstUpper }; } else { allUppers = new ClassNode[otherUppers.length + 1]; System.arraycopy(otherUppers, 0, allUppers, 1, otherUppers.length); allUppers[0] = firstUpper; } } else if (wildcardBinding.boundKind == Wildcard.SUPER) { lowerBound = convertToClassNode(wildcardBinding.bound); } else { assert (wildcardBinding.boundKind == Wildcard.UNBOUND); return JDTClassNode.unboundWildcard; } GenericsType t = new GenericsType(base, allUppers, lowerBound); t.setWildcard(true); ClassNode ref = ClassHelper.makeWithoutCaching(Object.class, false); ref.setGenericsTypes(new GenericsType[] { t }); return ref; }
From source file:org.eclipse.che.jdt.internal.core.search.matching.PatternLocator.java
License:Open Source License
protected void updateMatch(TypeBinding[] argumentsBinding, MatchLocator locator, char[][] patternArguments, boolean hasTypeParameters) { // Only possible if locator has an unit scope. if (locator.unitScope == null) return;//from ww w .j av a 2s .c o m // First compare lengthes int patternTypeArgsLength = patternArguments == null ? 0 : patternArguments.length; int typeArgumentsLength = argumentsBinding == null ? 0 : argumentsBinding.length; // Initialize match rule int matchRule = this.match.getRule(); if (this.match.isRaw()) { if (patternTypeArgsLength != 0) { matchRule &= ~SearchPattern.R_FULL_MATCH; } } if (hasTypeParameters) { matchRule = SearchPattern.R_ERASURE_MATCH; } // Compare arguments lengthes if (patternTypeArgsLength == typeArgumentsLength) { if (!this.match.isRaw() && hasTypeParameters) { // generic patterns are always not compatible match this.match.setRule(SearchPattern.R_ERASURE_MATCH); return; } } else { if (patternTypeArgsLength == 0) { if (!this.match.isRaw() || hasTypeParameters) { this.match.setRule(matchRule & ~SearchPattern.R_FULL_MATCH); } } else if (typeArgumentsLength == 0) { // raw binding is always compatible this.match.setRule(matchRule & ~SearchPattern.R_FULL_MATCH); } else { this.match.setRule(0); // impossible match } return; } if (argumentsBinding == null || patternArguments == null) { this.match.setRule(matchRule); return; } // Compare binding for each type argument only if pattern is not erasure only and at first level if (!hasTypeParameters && !this.match.isRaw() && (this.match.isEquivalent() || this.match.isExact())) { for (int i = 0; i < typeArgumentsLength; i++) { // Get parameterized type argument binding TypeBinding argumentBinding = argumentsBinding[i]; if (argumentBinding instanceof CaptureBinding) { WildcardBinding capturedWildcard = ((CaptureBinding) argumentBinding).wildcard; if (capturedWildcard != null) argumentBinding = capturedWildcard; } // Get binding for pattern argument char[] patternTypeArgument = patternArguments[i]; char patternWildcard = patternTypeArgument[0]; char[] patternTypeName = patternTypeArgument; int patternWildcardKind = -1; switch (patternWildcard) { case Signature.C_STAR: if (argumentBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; if (wildcardBinding.boundKind == Wildcard.UNBOUND) continue; } matchRule &= ~SearchPattern.R_FULL_MATCH; continue; // unbound parameter always match case Signature.C_EXTENDS: patternWildcardKind = Wildcard.EXTENDS; patternTypeName = CharOperation.subarray(patternTypeArgument, 1, patternTypeArgument.length); break; case Signature.C_SUPER: patternWildcardKind = Wildcard.SUPER; patternTypeName = CharOperation.subarray(patternTypeArgument, 1, patternTypeArgument.length); break; default: break; } patternTypeName = Signature.toCharArray(patternTypeName); TypeBinding patternBinding = locator.getType(patternTypeArgument, patternTypeName); // If have no binding for pattern arg, then we won't be able to refine accuracy if (patternBinding == null) { if (argumentBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; if (wildcardBinding.boundKind == Wildcard.UNBOUND) { matchRule &= ~SearchPattern.R_FULL_MATCH; } else { this.match.setRule(SearchPattern.R_ERASURE_MATCH); return; } } continue; } // Verify the pattern binding is compatible with match type argument binding switch (patternWildcard) { case Signature.C_STAR: // UNBOUND pattern // unbound always match => skip to next argument matchRule &= ~SearchPattern.R_FULL_MATCH; continue; case Signature.C_EXTENDS: // EXTENDS pattern if (argumentBinding.isWildcard()) { // argument is a wildcard WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; // It's ok if wildcards are identical if (wildcardBinding.boundKind == patternWildcardKind && TypeBinding.equalsEquals(wildcardBinding.bound, patternBinding)) { continue; } // Look for wildcard compatibility switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: if (wildcardBinding.bound == null || wildcardBinding.bound.isCompatibleWith(patternBinding)) { // valid when arg extends a subclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.SUPER: break; case Wildcard.UNBOUND: matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } } else if (argumentBinding.isCompatibleWith(patternBinding)) { // valid when arg is a subclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Signature.C_SUPER: // SUPER pattern if (argumentBinding.isWildcard()) { // argument is a wildcard WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; // It's ok if wildcards are identical if (wildcardBinding.boundKind == patternWildcardKind && TypeBinding.equalsEquals(wildcardBinding.bound, patternBinding)) { continue; } // Look for wildcard compatibility switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: break; case Wildcard.SUPER: if (wildcardBinding.bound == null || patternBinding.isCompatibleWith(wildcardBinding.bound)) { // valid only when arg super a superclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.UNBOUND: matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } } else if (patternBinding.isCompatibleWith(argumentBinding)) { // valid only when arg is a superclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; default: if (argumentBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argumentBinding; switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: if (wildcardBinding.bound == null || patternBinding.isCompatibleWith(wildcardBinding.bound)) { // valid only when arg extends a superclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.SUPER: if (wildcardBinding.bound == null || wildcardBinding.bound.isCompatibleWith(patternBinding)) { // valid only when arg super a subclass of pattern matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } break; case Wildcard.UNBOUND: matchRule &= ~SearchPattern.R_FULL_MATCH; continue; } } else if (TypeBinding.equalsEquals(argumentBinding, patternBinding)) // valid only when arg is equals to pattern continue; break; } // Argument does not match => erasure match will be the only possible one this.match.setRule(SearchPattern.R_ERASURE_MATCH); return; } } // Set match rule this.match.setRule(matchRule); }