List of usage examples for org.eclipse.jdt.core.compiler CharOperation contains
public static final boolean contains(char[] characters, char[] array)
From source file:com.codenvy.ide.ext.java.server.core.JavaConventions.java
License:Open Source License
/** * Validate the given Java type name, either simple or qualified, for the given source and compliance levels. * * <p>For example, <code>"java.lang.Object"</code>, or <code>"Object"</code>.</p> * * <p>The source level and compliance level values should be taken from the constant defined inside * {@link org.eclipse.jdt.core.JavaCore} class. The constants are named <code>JavaCore#VERSION_1_x</code>, x being set * between '1' and '8'./*ww w . j a v a 2s . c om*/ * </p> * * @param name the name of a type * @param sourceLevel the source level * @param complianceLevel the compliance level * @return a status object with code <code>IStatus.OK</code> if * the given name is valid as a Java type name, * a status with code <code>IStatus.WARNING</code> * indicating why the given name is discouraged, * otherwise a status object indicating what is wrong with * the name * @since 3.3 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_1 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_2 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_3 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_4 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_5 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_6 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_7 * @see org.eclipse.jdt.core.JavaCore#VERSION_1_8 */ public static IStatus validateJavaTypeName(String name, String sourceLevel, String complianceLevel) { if (name == null) { return new Status(IStatus.ERROR, org.eclipse.jdt.core.JavaCore.PLUGIN_ID, -1, Messages.convention_type_nullName, null); } String trimmed = name.trim(); if (!name.equals(trimmed)) { return new Status(IStatus.ERROR, org.eclipse.jdt.core.JavaCore.PLUGIN_ID, -1, Messages.convention_type_nameWithBlanks, null); } int index = name.lastIndexOf('.'); char[] scannedID; if (index == -1) { // simple name scannedID = scannedIdentifier(name, sourceLevel, complianceLevel); } else { // qualified name String pkg = name.substring(0, index).trim(); IStatus status = validatePackageName(pkg, sourceLevel, complianceLevel); if (!status.isOK()) { return status; } String type = name.substring(index + 1).trim(); scannedID = scannedIdentifier(type, sourceLevel, complianceLevel); } if (scannedID != null) { // IStatus status = ResourcesPlugin.getWorkspace().validateName(new String(scannedID), IResource.FILE); // if (!status.isOK()) { // return status; // } if (CharOperation.contains('$', scannedID)) { return new Status(IStatus.WARNING, org.eclipse.jdt.core.JavaCore.PLUGIN_ID, -1, Messages.convention_type_dollarName, null); } if ((scannedID.length > 0 && ScannerHelper.isLowerCase(scannedID[0]))) { return new Status(IStatus.WARNING, org.eclipse.jdt.core.JavaCore.PLUGIN_ID, -1, Messages.convention_type_lowercaseName, null); } return JavaModelStatus.VERIFIED_OK; } else { return new Status(IStatus.ERROR, org.eclipse.jdt.core.JavaCore.PLUGIN_ID, -1, Messages.bind(Messages.convention_type_invalidName, name), null); } }
From source file:com.codenvy.ide.ext.java.server.internal.core.search.matching.PatternLocator.java
License:Open Source License
protected int resolveLevelForType(char[] simpleNamePattern, char[] qualificationPattern, char[][][] patternTypeArguments, int depth, TypeBinding type) { // standard search with no generic additional information must succeed int level = resolveLevelForType(simpleNamePattern, qualificationPattern, type); if (level == IMPOSSIBLE_MATCH) return IMPOSSIBLE_MATCH; if (type == null || patternTypeArguments == null || patternTypeArguments.length == 0 || depth >= patternTypeArguments.length) { return level; }/*ww w .j a va 2s.c o m*/ // if pattern is erasure match (see bug 79790), commute impossible to erasure int impossible = this.isErasureMatch ? ERASURE_MATCH : IMPOSSIBLE_MATCH; // pattern has type parameter(s) or type argument(s) if (type.isGenericType()) { // Binding is generic, get its type variable(s) TypeVariableBinding[] typeVariables = null; if (type instanceof SourceTypeBinding) { SourceTypeBinding sourceTypeBinding = (SourceTypeBinding) type; typeVariables = sourceTypeBinding.typeVariables; } else if (type instanceof BinaryTypeBinding) { BinaryTypeBinding binaryTypeBinding = (BinaryTypeBinding) type; if (this.mustResolve) typeVariables = binaryTypeBinding.typeVariables(); // TODO (frederic) verify performance } if (patternTypeArguments[depth] != null && patternTypeArguments[depth].length > 0 && typeVariables != null && typeVariables.length > 0) { if (typeVariables.length != patternTypeArguments[depth].length) return IMPOSSIBLE_MATCH; } // TODO (frederic) do we need to verify each parameter? return level; // we can't do better } // raw type always match if (type.isRawType()) { return level; } // Standard types (i.e. neither generic nor parameterized nor raw types) // cannot match pattern with type parameters or arguments TypeBinding leafType = type.leafComponentType(); if (!leafType.isParameterizedType()) { return (patternTypeArguments[depth] == null || patternTypeArguments[depth].length == 0) ? level : IMPOSSIBLE_MATCH; } // Parameterized type ParameterizedTypeBinding paramTypeBinding = (ParameterizedTypeBinding) leafType; // Compare arguments only if there ones on both sides if (patternTypeArguments[depth] != null && patternTypeArguments[depth].length > 0 && paramTypeBinding.arguments != null && paramTypeBinding.arguments.length > 0) { // type parameters length must match at least specified type names length int length = patternTypeArguments[depth].length; if (paramTypeBinding.arguments.length != length) return IMPOSSIBLE_MATCH; // verify each pattern type parameter nextTypeArgument: for (int i = 0; i < length; i++) { char[] patternTypeArgument = patternTypeArguments[depth][i]; TypeBinding argTypeBinding = paramTypeBinding.arguments[i]; // get corresponding pattern wildcard switch (patternTypeArgument[0]) { case Signature.C_STAR: // unbound parameter always match case Signature.C_SUPER: // needs pattern type parameter binding // skip to next type argument as it will be resolved later continue nextTypeArgument; case Signature.C_EXTENDS: // remove wildcard from patter type argument patternTypeArgument = CharOperation.subarray(patternTypeArgument, 1, patternTypeArgument.length); break; default: // no wildcard break; } // get pattern type argument from its signature patternTypeArgument = Signature.toCharArray(patternTypeArgument); if (!this.isCaseSensitive) patternTypeArgument = CharOperation.toLowerCase(patternTypeArgument); boolean patternTypeArgHasAnyChars = CharOperation.contains(new char[] { '*', '?' }, patternTypeArgument); // Verify that names match... // ...special case for wildcard if (argTypeBinding instanceof CaptureBinding) { WildcardBinding capturedWildcard = ((CaptureBinding) argTypeBinding).wildcard; if (capturedWildcard != null) argTypeBinding = capturedWildcard; } if (argTypeBinding.isWildcard()) { WildcardBinding wildcardBinding = (WildcardBinding) argTypeBinding; switch (wildcardBinding.boundKind) { case Wildcard.EXTENDS: // Invalid if type argument is not exact if (patternTypeArgHasAnyChars) return impossible; continue nextTypeArgument; case Wildcard.UNBOUND: // there's no bound name to match => valid continue nextTypeArgument; } // Look if bound name match pattern type argument ReferenceBinding boundBinding = (ReferenceBinding) wildcardBinding.bound; if (CharOperation.match(patternTypeArgument, boundBinding.shortReadableName(), this.isCaseSensitive) || CharOperation.match(patternTypeArgument, boundBinding.readableName(), this.isCaseSensitive)) { // found name in hierarchy => match continue nextTypeArgument; } // If pattern is not exact then match fails if (patternTypeArgHasAnyChars) return impossible; // Look for bound name in type argument superclasses boundBinding = boundBinding.superclass(); while (boundBinding != null) { if (CharOperation.equals(patternTypeArgument, boundBinding.shortReadableName(), this.isCaseSensitive) || CharOperation.equals(patternTypeArgument, boundBinding.readableName(), this.isCaseSensitive)) { // found name in hierarchy => match continue nextTypeArgument; } else if (boundBinding.isLocalType() || boundBinding.isMemberType()) { // for local or member type, verify also source name (bug 81084) if (CharOperation.match(patternTypeArgument, boundBinding.sourceName(), this.isCaseSensitive)) continue nextTypeArgument; } boundBinding = boundBinding.superclass(); } return impossible; } // See if names match if (CharOperation.match(patternTypeArgument, argTypeBinding.shortReadableName(), this.isCaseSensitive) || CharOperation.match(patternTypeArgument, argTypeBinding.readableName(), this.isCaseSensitive)) { continue nextTypeArgument; } else if (argTypeBinding.isLocalType() || argTypeBinding.isMemberType()) { // for local or member type, verify also source name (bug 81084) if (CharOperation.match(patternTypeArgument, argTypeBinding.sourceName(), this.isCaseSensitive)) continue nextTypeArgument; } // If pattern is not exact then match fails if (patternTypeArgHasAnyChars) return impossible; // Scan hierarchy TypeBinding leafTypeBinding = argTypeBinding.leafComponentType(); if (leafTypeBinding.isBaseType()) return impossible; ReferenceBinding refBinding = ((ReferenceBinding) leafTypeBinding).superclass(); while (refBinding != null) { if (CharOperation.equals(patternTypeArgument, refBinding.shortReadableName(), this.isCaseSensitive) || CharOperation.equals(patternTypeArgument, refBinding.readableName(), this.isCaseSensitive)) { // found name in hierarchy => match continue nextTypeArgument; } else if (refBinding.isLocalType() || refBinding.isMemberType()) { // for local or member type, verify also source name (bug 81084) if (CharOperation.match(patternTypeArgument, refBinding.sourceName(), this.isCaseSensitive)) continue nextTypeArgument; } refBinding = refBinding.superclass(); } return impossible; } } // Recurse on enclosing type TypeBinding enclosingType = paramTypeBinding.enclosingType(); if (enclosingType != null && enclosingType.isParameterizedType() && depth < patternTypeArguments.length && qualificationPattern != null) { int lastDot = CharOperation.lastIndexOf('.', qualificationPattern); char[] enclosingQualificationPattern = lastDot == -1 ? null : CharOperation.subarray(qualificationPattern, 0, lastDot); char[] enclosingSimpleNamePattern = lastDot == -1 ? qualificationPattern : CharOperation.subarray(qualificationPattern, lastDot + 1, qualificationPattern.length); int enclosingLevel = resolveLevelForType(enclosingSimpleNamePattern, enclosingQualificationPattern, patternTypeArguments, depth + 1, enclosingType); if (enclosingLevel == impossible) return impossible; if (enclosingLevel == IMPOSSIBLE_MATCH) return IMPOSSIBLE_MATCH; } return level; }
From source file:org.codehaus.groovy.eclipse.codeassist.processors.GroovyProposalTypeSearchRequestor.java
License:Apache License
public void acceptType(char[] packageName, char[] simpleTypeName, char[][] enclosingTypeNames, int modifiers, AccessRestriction accessRestriction) { // does not check cancellation for every types to avoid performance // loss// w ww. j a va2s.com if ((this.foundTypesCount % CHECK_CANCEL_FREQUENCY) == 0) checkCancel(); this.foundTypesCount++; // ignore synthetic if (CharOperation.contains('$', simpleTypeName)) { return; } int accessibility = IAccessRule.K_ACCESSIBLE; if (accessRestriction != null) { switch (accessRestriction.getProblemId()) { case IProblem.ForbiddenReference: // forbidden references are removed return; case IProblem.DiscouragedReference: // discouraged references have a lower priority accessibility = IAccessRule.K_DISCOURAGED; break; } } if (this.acceptedTypes == null) { this.acceptedTypes = new ObjectVector(); } this.acceptedTypes .add(new AcceptedType(packageName, simpleTypeName, enclosingTypeNames, modifiers, accessibility)); }
From source file:org.eclipse.ajdt.internal.core.contentassist.ProposalRequestorWrapper.java
License:Open Source License
protected boolean shouldAccept(CompletionProposal proposal) { if (proposal.getKind() == CompletionProposal.FIELD_REF || proposal.getKind() == CompletionProposal.METHOD_REF) { if (world == null) { world = new AJWorldFacade(unit.getJavaProject().getProject()); }//from ww w . j a v a 2 s.c om ITDInfo info = world.findITDInfoFromTargetType(proposal.getDeclarationSignature(), proposal.getName()); if (info != null) { if (info.accessibility == Accessibility.PUBLIC) { // accessible everywhere return true; } else if (info.accessibility == Accessibility.PACKAGE) { // accessible only in package of declaring aspect if (((IPackageFragment) unit.getParent()).getElementName().equals(info.packageDeclaredIn)) { int oldFlags = proposal.getFlags(); oldFlags |= Flags.AccDefault; oldFlags &= ~Flags.AccPublic; proposal.setFlags(oldFlags); return true; } } else if (info.accessibility == Accessibility.PRIVATE) { // accessible only in declaring aspect's compilation unit if (unit.getElementName().startsWith(info.topLevelAspectName + ".") && ((IPackageFragment) unit.getParent()).getElementName() .equals(info.packageDeclaredIn)) { int oldFlags = proposal.getFlags(); oldFlags |= Flags.AccPrivate; oldFlags &= ~Flags.AccPublic; proposal.setFlags(oldFlags); return true; } } return false; } else { // not an ITD return true; } } else if (proposal.getKind() == CompletionProposal.LOCAL_VARIABLE_REF) { // check to see if this is the proposal that has been added by the context switch for ITDs if (contextSwitchIgnore(proposal)) { return false; } } else if (proposal.getKind() == CompletionProposal.TYPE_REF) { // check to see if this is an ITIT type that should not be see char[] typeName = (char[]) ReflectionUtils.getPrivateField(InternalCompletionProposal.class, "typeName", (InternalCompletionProposal) proposal); if (typeName != null && CharOperation.contains('$', typeName)) { return false; } } return true; }
From source file:org.eclipse.objectteams.otdt.core.compiler.OTNameUtils.java
License:Open Source License
/** Remove all occurrences of '__OT__' from a given type name. */ public static char[] removeOTDelim(char[] typeName) { if (!CharOperation.contains(OT_DELIM_NAME, typeName)) return typeName; char[] strippedName = new char[0]; int start = 0; int pos = CharOperation.indexOf(OT_DELIM_NAME, typeName, true, start); while (pos > -1) { strippedName = CharOperation.concat(strippedName, CharOperation.subarray(typeName, start, pos)); start = pos;/* www. j a va 2s. c o m*/ pos = CharOperation.indexOf(OT_DELIM_NAME, typeName, true, start + 1); } strippedName = CharOperation.concat(strippedName, CharOperation.subarray(typeName, start + OT_DELIM_LEN, -1)); return strippedName; }