/** @see java.lang.Object#toString() */ public String toString() { if (this.hasTypeAnnotations()) return annotatedDebugName(); switch (this.boundKind) { case Wildcard.UNBOUND: return new String(TypeConstants.WILDCARD_NAME); case Wildcard.EXTENDS: if (this.otherBounds == null) return new String( CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.debugName().toCharArray())); StringBuffer buffer = new StringBuffer(this.bound.debugName()); for (int i = 0, length = this.otherBounds.length; i < length; i++) { buffer.append('&').append(this.otherBounds[i].debugName()); } return buffer.toString(); default: // SUPER return new String( CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.debugName().toCharArray())); } }
public String annotatedDebugName() { StringBuffer buffer = new StringBuffer(16); AnnotationBinding[] annotations = getTypeAnnotations(); for (int i = 0, length = annotations == null ? 0 : annotations.length; i < length; i++) { buffer.append(annotations[i]); buffer.append(' '); } switch (this.boundKind) { case Wildcard.UNBOUND: return buffer.append(TypeConstants.WILDCARD_NAME).toString(); case Wildcard.EXTENDS: if (this.otherBounds == null) return buffer .append( CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.annotatedDebugName().toCharArray())) .toString(); buffer.append(this.bound.annotatedDebugName()); for (int i = 0, length = this.otherBounds.length; i < length; i++) { buffer.append(" & ").append(this.otherBounds[i].annotatedDebugName()); // $NON-NLS-1$ } return buffer.toString(); default: // SUPER return buffer .append( CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.annotatedDebugName().toCharArray())) .toString(); } }
/* (non-Javadoc) * @see org.eclipse.jdt.internal.compiler.lookup.Binding#shortReadableName() */ public char[] shortReadableName() { switch (this.boundKind) { case Wildcard.UNBOUND: return TypeConstants.WILDCARD_NAME; case Wildcard.EXTENDS: if (this.otherBounds == null) return CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.shortReadableName()); StringBuffer buffer = new StringBuffer(10); buffer.append(this.bound.shortReadableName()); for (int i = 0, length = this.otherBounds.length; i < length; i++) { buffer.append('&').append(this.otherBounds[i].shortReadableName()); } int length; char[] result = new char[length = buffer.length()]; buffer.getChars(0, length, result, 0); return result; default: // SUPER return CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.shortReadableName()); } }
public char[] genericTypeSignature() { // since we have no wildcard, we combine the logic from CaptureBinding plus WildcardBinding // here: if (this.genericTypeSignature == null) { char[] boundSignature; try { if (this.recursionLevel++ > 0 || this.firstBound == null) { boundSignature = TypeConstants.WILDCARD_STAR; } else if (this.upperBounds != null) { boundSignature = CharOperation.concat( TypeConstants.WILDCARD_PLUS, this.firstBound.genericTypeSignature()); } else if (this.lowerBound != null) { boundSignature = CharOperation.concat( TypeConstants.WILDCARD_MINUS, this.lowerBound.genericTypeSignature()); } else { boundSignature = TypeConstants.WILDCARD_STAR; } this.genericTypeSignature = CharOperation.concat(TypeConstants.WILDCARD_CAPTURE, boundSignature); } finally { this.recursionLevel--; } } return this.genericTypeSignature; }
boolean matchTypeDeclaration( TypeDeclarationPattern pattern, Object binaryInfo, IBinaryType enclosingBinaryType) { if (!(binaryInfo instanceof IBinaryType)) return false; IBinaryType type = (IBinaryType) binaryInfo; char[] fullyQualifiedTypeName = convertClassFileFormat(type.getName()); boolean qualifiedPattern = pattern instanceof QualifiedTypeDeclarationPattern; if (pattern.enclosingTypeNames == null || qualifiedPattern) { char[] simpleName = (pattern.getMatchMode() == SearchPattern.R_PREFIX_MATCH) ? CharOperation.concat(pattern.simpleName, IIndexConstants.ONE_STAR) : pattern.simpleName; char[] pkg = qualifiedPattern ? ((QualifiedTypeDeclarationPattern) pattern).qualification : pattern.pkg; if (!checkTypeName( simpleName, pkg, fullyQualifiedTypeName, pattern.isCaseSensitive(), pattern.isCamelCase())) return false; } else { char[] enclosingTypeName = CharOperation.concatWith(pattern.enclosingTypeNames, '.'); char[] patternString = pattern.pkg == null ? enclosingTypeName : CharOperation.concat(pattern.pkg, enclosingTypeName, '.'); if (!checkTypeName( pattern.simpleName, patternString, fullyQualifiedTypeName, pattern.isCaseSensitive(), pattern.isCamelCase())) return false; } int kind = TypeDeclaration.kind(type.getModifiers()); switch (pattern.typeSuffix) { case CLASS_SUFFIX: return kind == TypeDeclaration.CLASS_DECL; case INTERFACE_SUFFIX: return kind == TypeDeclaration.INTERFACE_DECL; case ENUM_SUFFIX: return kind == TypeDeclaration.ENUM_DECL; case ANNOTATION_TYPE_SUFFIX: return kind == TypeDeclaration.ANNOTATION_TYPE_DECL; case CLASS_AND_INTERFACE_SUFFIX: return kind == TypeDeclaration.CLASS_DECL || kind == TypeDeclaration.INTERFACE_DECL; case CLASS_AND_ENUM_SUFFIX: return kind == TypeDeclaration.CLASS_DECL || kind == TypeDeclaration.ENUM_DECL; case INTERFACE_AND_ANNOTATION_SUFFIX: return kind == TypeDeclaration.INTERFACE_DECL || kind == TypeDeclaration.ANNOTATION_TYPE_DECL; case TYPE_SUFFIX: // nothing } return true; }
/* (non-Javadoc) * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#sourceName() */ public char[] sourceName() { switch (this.boundKind) { case Wildcard.UNBOUND: return TypeConstants.WILDCARD_NAME; case Wildcard.EXTENDS: return CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_EXTENDS, this.bound.sourceName()); default: // SUPER return CharOperation.concat( TypeConstants.WILDCARD_NAME, TypeConstants.WILDCARD_SUPER, this.bound.sourceName()); } }
/** * Answer the receiver's constant pool name. NOTE: This method should only be used during/after * code gen. e.g. '[Ljava/lang/Object;' */ public char[] constantPoolName() { if (constantPoolName != null) return constantPoolName; char[] brackets = new char[dimensions]; for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '['; return constantPoolName = CharOperation.concat(brackets, leafComponentType.signature()); }
/* (non-Javadoc) * @see org.eclipse.jdt.internal.compiler.lookup.TypeBinding#signature() */ public char[] genericTypeSignature() { if (this.genericSignature == null) { switch (this.boundKind) { case Wildcard.UNBOUND: this.genericSignature = TypeConstants.WILDCARD_STAR; break; case Wildcard.EXTENDS: this.genericSignature = CharOperation.concat(TypeConstants.WILDCARD_PLUS, this.bound.genericTypeSignature()); break; default: // SUPER this.genericSignature = CharOperation.concat(TypeConstants.WILDCARD_MINUS, this.bound.genericTypeSignature()); } } return this.genericSignature; }
public char[] genericTypeSignature() { if (this.genericTypeSignature == null) { this.genericTypeSignature = CharOperation.concat( TypeConstants.WILDCARD_CAPTURE, this.wildcard.genericTypeSignature()); } return this.genericTypeSignature; }
public char[] sourceName() { char[] brackets = new char[dimensions * 2]; for (int i = dimensions * 2 - 1; i >= 0; i -= 2) { brackets[i] = ']'; brackets[i - 1] = '['; } return CharOperation.concat(leafComponentType.sourceName(), brackets); }
public char[] readableName() /* java.lang.Object[] */ { char[] brackets = new char[dimensions * 2]; for (int i = dimensions * 2 - 1; i >= 0; i -= 2) { brackets[i] = ']'; brackets[i - 1] = '['; } return CharOperation.concat(leafComponentType.readableName(), brackets); }
public SyntheticArgumentBinding(ReferenceBinding enclosingType) { super( CharOperation.concat( TypeConstants.SYNTHETIC_ENCLOSING_INSTANCE_PREFIX, String.valueOf(enclosingType.depth()).toCharArray()), enclosingType, ClassFileConstants.AccFinal, true); }
public char[] genericTypeSignature() { if (this.genericTypeSignature == null) { char[] brackets = new char[dimensions]; for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '['; this.genericTypeSignature = CharOperation.concat(brackets, leafComponentType.genericTypeSignature()); } return this.genericTypeSignature; }
public SyntheticArgumentBinding(LocalVariableBinding actualOuterLocalVariable) { super( CharOperation.concat( TypeConstants.SYNTHETIC_OUTER_LOCAL_PREFIX, actualOuterLocalVariable.name), actualOuterLocalVariable.type, ClassFileConstants.AccFinal, true); this.actualOuterLocalVariable = actualOuterLocalVariable; }
/* * genericTypeKey {rank}*|+|- [boundKey] * p.X<T> { X<?> ... } --> Lp/X<TT;>;{0}* */ public char[] computeUniqueKey(boolean isLeaf) { char[] genericTypeKey = this.genericType.computeUniqueKey(false /*not a leaf*/); char[] wildCardKey; // We now encode the rank also in the binding key - // https://bugs.eclipse.org/bugs/show_bug.cgi?id=234609 char[] rankComponent = ('{' + String.valueOf(this.rank) + '}').toCharArray(); switch (this.boundKind) { case Wildcard.UNBOUND: wildCardKey = TypeConstants.WILDCARD_STAR; break; case Wildcard.EXTENDS: wildCardKey = CharOperation.concat( TypeConstants.WILDCARD_PLUS, this.bound.computeUniqueKey(false /*not a leaf*/)); break; default: // SUPER wildCardKey = CharOperation.concat( TypeConstants.WILDCARD_MINUS, this.bound.computeUniqueKey(false /*not a leaf*/)); break; } return CharOperation.concat(genericTypeKey, rankComponent, wildCardKey); }
public int match(ASTNode node, MatchingNodeSet nodeSet) { int declarationsLevel = IMPOSSIBLE_MATCH; if (this.pattern.findReferences) { if (node instanceof ImportReference) { // With static import, we can have static method reference in import reference ImportReference importRef = (ImportReference) node; int length = importRef.tokens.length - 1; if (importRef.isStatic() && ((importRef.bits & ASTNode.OnDemand) == 0) && matchesName(this.pattern.selector, importRef.tokens[length])) { char[][] compoundName = new char[length][]; System.arraycopy(importRef.tokens, 0, compoundName, 0, length); char[] declaringType = CharOperation.concat( this.pattern.declaringQualification, this.pattern.declaringSimpleName, '.'); if (matchesName(declaringType, CharOperation.concatWith(compoundName, '.'))) { declarationsLevel = this.pattern.mustResolve ? POSSIBLE_MATCH : ACCURATE_MATCH; } } } } return nodeSet.addMatch(node, declarationsLevel); }
/** @return char[][] */ public char[][] getParameterizedTypeName() { StringBuffer buffer = new StringBuffer(5); buffer.append(this.token).append('<'); for (int i = 0, length = this.typeArguments.length; i < length; i++) { if (i > 0) buffer.append(','); buffer.append( CharOperation.concatWith(this.typeArguments[i].getParameterizedTypeName(), '.')); } buffer.append('>'); int nameLength = buffer.length(); char[] name = new char[nameLength]; buffer.getChars(0, nameLength, name, 0); int dim = this.dimensions; if (dim > 0) { char[] dimChars = new char[dim * 2]; for (int i = 0; i < dim; i++) { int index = i * 2; dimChars[index] = '['; dimChars[index + 1] = ']'; } name = CharOperation.concat(name, dimChars); } return new char[][] {name}; }
/** T::Ljava/util/Map;:Ljava/io/Serializable; T:LY<TT;> */ public char[] genericTypeSignature() { if (this.genericTypeSignature != null) return this.genericTypeSignature; return this.genericTypeSignature = CharOperation.concat('T', this.sourceName, ';'); }
protected void reportDeclaration( MethodBinding methodBinding, MatchLocator locator, SimpleSet knownMethods) throws CoreException { ReferenceBinding declaringClass = methodBinding.declaringClass; IType type = locator.lookupType(declaringClass); if (type == null) return; // case of a secondary type // Report match for binary if (type.isBinary()) { IMethod method = null; TypeBinding[] parameters = methodBinding.original().parameters; int parameterLength = parameters.length; char[][] parameterTypes = new char[parameterLength][]; for (int i = 0; i < parameterLength; i++) { char[] typeName = parameters[i].qualifiedSourceName(); for (int j = 0, dim = parameters[i].dimensions(); j < dim; j++) { typeName = CharOperation.concat(typeName, new char[] {'[', ']'}); } parameterTypes[i] = typeName; } method = locator.createBinaryMethodHandle(type, methodBinding.selector, parameterTypes); if (method == null || knownMethods.addIfNotIncluded(method) == null) return; IResource resource = type.getResource(); if (resource == null) resource = type.getJavaProject().getProject(); IBinaryType info = locator.getBinaryInfo( (org.eclipse.jdt.internal.core.ClassFile) type.getClassFile(), resource); locator.reportBinaryMemberDeclaration( resource, method, methodBinding, info, SearchMatch.A_ACCURATE); return; } // When source is available, report match if method is found in the declaring type IResource resource = type.getResource(); if (declaringClass instanceof ParameterizedTypeBinding) declaringClass = ((ParameterizedTypeBinding) declaringClass).genericType(); ClassScope scope = ((SourceTypeBinding) declaringClass).scope; if (scope != null) { TypeDeclaration typeDecl = scope.referenceContext; AbstractMethodDeclaration methodDecl = typeDecl.declarationOf(methodBinding.original()); if (methodDecl != null) { // Create method handle from method declaration String methodName = new String(methodBinding.selector); Argument[] arguments = methodDecl.arguments; int length = arguments == null ? 0 : arguments.length; String[] parameterTypes = new String[length]; for (int i = 0; i < length; i++) { char[][] typeName = arguments[i].type.getParameterizedTypeName(); parameterTypes[i] = Signature.createTypeSignature(CharOperation.concatWith(typeName, '.'), false); } IMethod method = type.getMethod(methodName, parameterTypes); if (method == null || knownMethods.addIfNotIncluded(method) == null) return; // Create and report corresponding match int offset = methodDecl.sourceStart; this.match = new MethodDeclarationMatch( method, SearchMatch.A_ACCURATE, offset, methodDecl.sourceEnd - offset + 1, locator.getParticipant(), resource); locator.report(this.match); } } }
/** * In case emulating local variables, wrap the (recovered) statements inside a try statement so as * to achieve local state commiting (copy local vars back to fields). The CSToCuMapper could not * be used, since it could have interfered with the syntax recovery specific to code snippets. */ protected void consumeMethodDeclaration(boolean isNotAbstract) { // MethodDeclaration ::= MethodHeader MethodBody // AbstractMethodDeclaration ::= MethodHeader ';' super.consumeMethodDeclaration(isNotAbstract); // now we know that we have a method declaration at the top of the ast stack MethodDeclaration methodDecl = (MethodDeclaration) this.astStack[this.astPtr]; // automatically wrap the last statement inside a return statement, if it is an expression // support have to be defined at toplevel only if (this.isTopLevelType()) { int last = methodDecl.statements == null ? -1 : methodDecl.statements.length - 1; if (last >= 0 && methodDecl.statements[last] instanceof Expression) { Expression lastExpression = (Expression) methodDecl.statements[last]; methodDecl.statements[last] = new CodeSnippetReturnStatement( lastExpression, lastExpression.sourceStart, lastExpression.sourceEnd); } } int start = methodDecl.bodyStart - 1, end = start; long position = ((long) start << 32) + end; long[] positions = new long[] {position}; if (this.evaluationContext.localVariableNames != null) { int varCount = this.evaluationContext.localVariableNames.length; // n local decls+ try statement // generate n local variable declarations: [type] [name] = val$[name]; Statement[] newStatements = new Statement[varCount + 1]; for (int i = 0; i < varCount; i++) { char[] trimmedTypeName = this.evaluationContext.localVariableTypeNames[i]; int nameEnd = CharOperation.indexOf('[', trimmedTypeName); if (nameEnd >= 0) { trimmedTypeName = CharOperation.subarray(trimmedTypeName, 0, nameEnd); } nameEnd = CharOperation.indexOf(' ', trimmedTypeName); if (nameEnd >= 0) { trimmedTypeName = CharOperation.subarray(trimmedTypeName, 0, nameEnd); } TypeReference typeReference = new QualifiedTypeReference(CharOperation.splitOn('.', trimmedTypeName), positions); int dimCount = CharOperation.occurencesOf('[', this.evaluationContext.localVariableTypeNames[i]); if (dimCount > 0) { typeReference = this.copyDims(typeReference, dimCount); } NameReference init = new SingleNameReference( CharOperation.concat( LOCAL_VAR_PREFIX, this.evaluationContext.localVariableNames[i]), position); LocalDeclaration declaration = new LocalDeclaration(this.evaluationContext.localVariableNames[i], start, end); declaration.initialization = init; declaration.type = typeReference; declaration.modifiers = this.evaluationContext.localVariableModifiers[i]; newStatements[i] = declaration; } // generate try { [snippet] } finally { [save locals to fields] } // try block TryStatement tryStatement = new TryStatement(); Block tryBlock = new Block(methodDecl.explicitDeclarations); tryBlock.sourceStart = start; tryBlock.sourceEnd = end; tryBlock.statements = methodDecl.statements; // snippet statements tryStatement.tryBlock = tryBlock; // finally block Block finallyBlock = new Block(0); finallyBlock.sourceStart = start; finallyBlock.sourceEnd = end; finallyBlock.statements = new Statement[varCount]; for (int i = 0; i < varCount; i++) { finallyBlock.statements[i] = new Assignment( new SingleNameReference( CharOperation.concat( LOCAL_VAR_PREFIX, this.evaluationContext.localVariableNames[i]), position), new SingleNameReference(this.evaluationContext.localVariableNames[i], position), (int) position); } tryStatement.finallyBlock = finallyBlock; newStatements[varCount] = tryStatement; methodDecl.statements = newStatements; } }
/* * brakets leafUniqueKey * p.X[][] --> [[Lp/X; */ public char[] computeUniqueKey(boolean isLeaf) { char[] brackets = new char[dimensions]; for (int i = dimensions - 1; i >= 0; i--) brackets[i] = '['; return CharOperation.concat(brackets, this.leafComponentType.computeUniqueKey(isLeaf)); }