protected void createFragmentForArray(String signature, StringBuilder uriBuilder) {
   String elementType = Signature.getElementType(signature);
   createFragment(elementType, uriBuilder);
   int dim = Signature.getArrayCount(signature);
   for (int i = 0; i < dim; i++) {
     uriBuilder.append("[]");
   }
 }
  /**
   * Returns the qualified signature corresponding to <code>signature</code>.
   *
   * @param signature the signature to qualify
   * @param context the type inside which an unqualified type will be resolved to find the
   *     qualifier, or <code>null</code> if no context is available
   * @return the qualified signature
   */
  public static String qualifySignature(final String signature, final IType context) {
    if (context == null) return signature;

    String qualifier = Signature.getSignatureQualifier(signature);
    if (qualifier.length() > 0) return signature;

    String elementType = Signature.getElementType(signature);
    String erasure = Signature.getTypeErasure(elementType);
    String simpleName = Signature.getSignatureSimpleName(erasure);
    String genericSimpleName = Signature.getSignatureSimpleName(elementType);

    int dim = Signature.getArrayCount(signature);

    try {
      String[][] strings = context.resolveType(simpleName);
      if (strings != null && strings.length > 0) qualifier = strings[0][0];
    } catch (JavaModelException e) {
      // ignore - not found
    }

    if (qualifier.length() == 0) return signature;

    String qualifiedType = Signature.toQualifiedName(new String[] {qualifier, genericSimpleName});
    String qualifiedSignature = Signature.createTypeSignature(qualifiedType, true);
    String newSignature = Signature.createArraySignature(qualifiedSignature, dim);

    return newSignature;
  }
Exemple #3
0
 public static String getReturnTypeString(IMethod method, boolean classTypesOnly) {
   try {
     String qualifiedReturnType = Signature.getReturnType(method.getSignature());
     if (!classTypesOnly
         || qualifiedReturnType.startsWith("L")
         || qualifiedReturnType.startsWith("Q")) {
       return Signature.getSignatureSimpleName(qualifiedReturnType.replace('/', '.'));
     }
   } catch (IllegalArgumentException e) {
   } catch (JavaModelException e) {
   }
   return null;
 }
 public void computeTypeName(String signature, StringBuilder uriBuilder) {
   int signatureKind = Signature.getTypeSignatureKind(signature);
   switch (signatureKind) {
     case Signature.CLASS_TYPE_SIGNATURE:
     case Signature.BASE_TYPE_SIGNATURE:
     case Signature.ARRAY_TYPE_SIGNATURE:
     case Signature.TYPE_VARIABLE_SIGNATURE:
       String erased = getTypeErasure(signature);
       uriBuilder.append(Signature.toString(erased));
       return;
     default:
       throw new IllegalStateException("Unexpected Signature: " + signature);
   }
 }
 protected void createResourceURIForClassImpl(String signature, StringBuilder uriBuilder) {
   String topLevel = signature;
   int idx = topLevel.indexOf('$');
   if (idx != -1) {
     topLevel = topLevel.substring(0, idx) + ';';
     if (topLevel.endsWith(".;") || topLevel.endsWith("$;")) {
       topLevel = signature.substring(1, signature.length() - 1);
     } else {
       topLevel = Signature.toString(topLevel);
     }
   } else {
     topLevel = Signature.toString(topLevel);
   }
   uriBuilder.append(URIHelperConstants.OBJECTS).append(topLevel);
 }
Exemple #6
0
 public static String[] getParameterTypesString(IMethod method) {
   try {
     String[] parameterQualifiedTypes = Signature.getParameterTypes(method.getSignature());
     int length = parameterQualifiedTypes == null ? 0 : parameterQualifiedTypes.length;
     String[] parameterPackages = new String[length];
     for (int i = 0; i < length; i++) {
       parameterQualifiedTypes[i] = parameterQualifiedTypes[i].replace('/', '.');
       parameterPackages[i] = Signature.getSignatureSimpleName(parameterQualifiedTypes[i]);
     }
     return parameterPackages;
   } catch (IllegalArgumentException e) {
   } catch (JavaModelException e) {
   }
   return null;
 }
  /**
   * Returns the lower bound of a type signature. Returns the null type signature if <code>signature
   * </code> is a wildcard or upper bound (<code>? extends T</code>); returns the signature of the
   * type <code>T</code> of a lower bound (<code>? super T</code>) or <code>signature</code> itself
   * if it is not a bound signature.
   *
   * @param signature the signature
   * @return the lower bound signature of <code>signature</code>
   */
  public static char[] getLowerBound(char[] signature) {
    if (signature.length < 1) return signature;

    if (signature.length == 1 && signature[0] == Signature.C_STAR) return signature;

    int superIndex = indexOf(signature, Signature.C_EXTENDS);
    if (superIndex == 0) return NULL_TYPE_SIGNATURE_ARRAY;

    if (superIndex != -1) {
      char afterSuper = signature[superIndex + 1];
      if (afterSuper == Signature.C_STAR || afterSuper == Signature.C_EXTENDS)
        // impossible captured type
        return NULL_TYPE_SIGNATURE_ARRAY;
    }

    char[][] typeArguments = Signature.getTypeArguments(signature);
    for (int i = 0; i < typeArguments.length; i++)
      if (Arrays.equals(typeArguments[i], NULL_TYPE_SIGNATURE_ARRAY))
        return NULL_TYPE_SIGNATURE_ARRAY;

    if (signature[0] == Signature.C_SUPER) {
      char[] type = new char[signature.length - 1];
      System.arraycopy(signature, 1, type, 0, signature.length - 1);
      return type;
    }

    return signature;
  }
 public void computeParameter(String signature, StringBuilder uriBuilder) {
   int signatureKind = Signature.getTypeSignatureKind(signature);
   if (signatureKind == Signature.WILDCARD_TYPE_SIGNATURE) {
     switch (signature.charAt(0)) {
       case '*':
         {
           uriBuilder.append("? extends java.lang.Object");
         }
         break;
       case '+':
         {
           uriBuilder.append("? extends ");
           String upperBoundSignature = signature.substring(1);
           computeParameterizedTypeName(upperBoundSignature, uriBuilder);
         }
         break;
       case '-':
         {
           uriBuilder.append("? extends java.lang.Object & super ");
           String lowerBoundSignature = signature.substring(1);
           computeParameterizedTypeName(lowerBoundSignature, uriBuilder);
         }
         break;
       default:
         throw new IllegalArgumentException("Signature: " + signature);
     }
   } else {
     computeParameterizedTypeName(signature, uriBuilder);
   }
 }
  private JavaElement getJavaElement(LocalVariableBinding binding) {
    LocalDeclaration local = binding.declaration;

    JavaElement parent = null;
    ReferenceContext referenceContext =
        binding.declaringScope.isLambdaSubscope()
            ? binding.declaringScope.namedMethodScope().referenceContext()
            : binding.declaringScope.referenceContext();
    if (referenceContext instanceof AbstractMethodDeclaration) {
      AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) referenceContext;
      parent = this.getJavaElementOfCompilationUnit(methodDeclaration, methodDeclaration.binding);
    } else if (referenceContext instanceof TypeDeclaration) {
      // Local variable is declared inside an initializer
      TypeDeclaration typeDeclaration = (TypeDeclaration) referenceContext;

      JavaElement type =
          this.getJavaElementOfCompilationUnit(typeDeclaration, typeDeclaration.binding);
      parent = Util.getUnresolvedJavaElement(local.sourceStart, local.sourceEnd, type);
    }
    if (parent == null) return null;

    return new LocalVariable(
        parent,
        new String(local.name),
        local.declarationSourceStart,
        local.declarationSourceEnd,
        local.sourceStart,
        local.sourceEnd,
        local.type == null
            ? Signature.createTypeSignature(binding.type.signableName(), true)
            : Util.typeSignature(local.type),
        binding.declaration.annotations,
        local.modifiers,
        local.getKind() == AbstractVariableDeclaration.PARAMETER);
  }
Exemple #10
0
 private String extractSignature(String sig) {
   String args = Signature.toString(sig);
   args = args.substring(args.indexOf("(") + 1, args.indexOf(")"));
   args = args.replaceAll("\\s+", "");
   args = args.replaceAll("/", ".");
   return args;
 }
Exemple #11
0
  public static String getMethodSignature(
      final MethodLocation location, final boolean withReturnType) {
    String methodSignature = location.getLocationMethodSignature().replace('/', '.');
    if (methodSignature.length() == 0) return methodSignature;

    final int signatureStartIndex = methodSignature.indexOf('(');
    if (signatureStartIndex < 0) {
      return methodSignature;
    }

    String methodName = methodSignature.substring(0, signatureStartIndex);
    methodName = methodName.substring(methodName.lastIndexOf('.') + 1);

    if (methodName.equals("<clinit>")) { // $NON-NLS-1$
      return CLINIT_MSG;
    }

    boolean includeReturnType = withReturnType;
    if (methodName.equals("<init>")) { // $NON-NLS-1$
      final String className = getClassName(location);
      methodName = className.substring(className.lastIndexOf('.') + 1);
      includeReturnType = false;
    }
    methodSignature = methodSignature.substring(signatureStartIndex);
    return Signature.toString(
        methodSignature,
        methodName,
        null /* parameterNames */,
        true /* fullyQualifiedName */,
        includeReturnType);
  }
Exemple #12
0
 /**
  * Tries to find the given {@link IApiMethod} in the given {@link IType}. If a matching method is
  * not found <code>null</code> is returned
  *
  * @param type the type top look in for the given {@link IApiMethod}
  * @param method the {@link IApiMethod} to look for
  * @return the {@link IMethod} from the given {@link IType} that matches the given {@link
  *     IApiMethod} or <code>null</code> if no matching method is found
  * @throws JavaModelException
  * @throws CoreException
  */
 protected IMethod findMethodInType(IType type, IApiMethod method)
     throws JavaModelException, CoreException {
   String[] parameterTypes = Signature.getParameterTypes(method.getSignature());
   for (int i = 0; i < parameterTypes.length; i++) {
     parameterTypes[i] = parameterTypes[i].replace('/', '.');
   }
   String methodname = method.getName();
   if (method.isConstructor()) {
     IApiType enclosingType = method.getEnclosingType();
     if (enclosingType.isMemberType() && !Flags.isStatic(enclosingType.getModifiers())) {
       // remove the synthetic argument that corresponds to the enclosing type
       int length = parameterTypes.length - 1;
       System.arraycopy(parameterTypes, 1, (parameterTypes = new String[length]), 0, length);
     }
     methodname = enclosingType.getSimpleName();
   }
   IMethod Qmethod = type.getMethod(methodname, parameterTypes);
   IMethod[] methods = type.getMethods();
   IMethod match = null;
   for (int i = 0; i < methods.length; i++) {
     IMethod m = methods[i];
     if (m.isSimilar(Qmethod)) {
       match = m;
       break;
     }
   }
   return match;
 }
Exemple #13
0
  /**
   * Gets the fully qualified name of the supplied java element.
   *
   * <p>NOTE: For easy of determining fields and method segments, they are appended with a javadoc
   * style '#' instead of the normal '.'.
   *
   * @param element The IJavaElement.
   * @return The fully qualified name.
   */
  public static String getFullyQualifiedName(IJavaElement element) {
    IJavaElement parent = element;
    while (parent.getElementType() != IJavaElement.COMPILATION_UNIT
        && parent.getElementType() != IJavaElement.CLASS_FILE) {
      parent = parent.getParent();
    }

    StringBuffer elementName =
        new StringBuffer()
            .append(parent.getParent().getElementName())
            .append('.')
            .append(FileUtils.getFileName(parent.getElementName()));

    switch (element.getElementType()) {
      case IJavaElement.FIELD:
        IField field = (IField) element;
        elementName.append('#').append(field.getElementName());
        break;
      case IJavaElement.METHOD:
        IMethod method = (IMethod) element;
        elementName.append('#').append(method.getElementName()).append('(');
        String[] parameters = method.getParameterTypes();
        for (int ii = 0; ii < parameters.length; ii++) {
          if (ii != 0) {
            elementName.append(", ");
          }
          elementName.append(Signature.toString(parameters[ii]).replace('/', '.'));
        }
        elementName.append(')');
        break;
    }

    return elementName.toString();
  }
Exemple #14
0
  private static String[] getParameterTypesAsStringArray(IMethod method) {
    Set<String> typeParameterNames = new HashSet<String>();
    try {
      for (ITypeParameter param : method.getDeclaringType().getTypeParameters()) {
        typeParameterNames.add(param.getElementName());
      }
      for (ITypeParameter param : method.getTypeParameters()) {
        typeParameterNames.add(param.getElementName());
      }
    } catch (JavaModelException e) {
    }
    String[] parameterTypesAsString = new String[method.getParameterTypes().length];
    for (int i = 0; i < method.getParameterTypes().length; i++) {
      String parameterTypeString = Signature.getElementType(method.getParameterTypes()[i]);
      boolean isArray = !parameterTypeString.equals(method.getParameterTypes()[i]);

      String parameterType =
          resolveClassNameBySignature(parameterTypeString, method.getDeclaringType());
      if (typeParameterNames.contains(parameterType)) {
        parameterTypesAsString[i] =
            Object.class.getName() + (isArray ? ClassUtils.ARRAY_SUFFIX : "");
      } else {
        parameterTypesAsString[i] = parameterType + (isArray ? ClassUtils.ARRAY_SUFFIX : "");
      }
    }
    return parameterTypesAsString;
  }
  public void switchToJavaEditor(IType type, String methodName, List<String> parameterTypes) {
    JavaEditor javaEditor = openJavaEditor(type);
    if (javaEditor == null) {
      return;
    }

    IMethod newMethod = null;
    try {
      String[] parameterTypeSignatures = new String[parameterTypes.size()];
      for (int i = 0; i < parameterTypeSignatures.length; i++) {
        String qualifiedName = parameterTypes.get(i);
        String signature = Signature.createTypeSignature(qualifiedName, true);
        parameterTypeSignatures[i] = signature;
      }

      newMethod = JavaModelUtil.findMethod(methodName, parameterTypeSignatures, false, type);
    } catch (JavaModelException e) {
      // ignore this
    }

    if (newMethod == null) {
      return;
    }

    javaEditor.setSelection(newMethod);
  }
 /*
  * (non-Javadoc)
  * @see org.eclipse.pde.api.tools.internal.builder.AbstractProblemDetector#
  * getMessageArgs
  * (org.eclipse.pde.api.tools.internal.provisional.builder.IReference)
  */
 @Override
 protected String[] getMessageArgs(IReference reference) throws CoreException {
   IApiMember member = reference.getMember();
   String eeValue = ProfileModifiers.getName(this.referenceEEs.get(reference).intValue());
   String simpleTypeName = Signatures.getSimpleTypeName(reference.getReferencedTypeName());
   if (simpleTypeName.indexOf('$') != -1) {
     simpleTypeName = simpleTypeName.replace('$', '.');
   }
   switch (reference.getReferenceType()) {
     case IReference.T_TYPE_REFERENCE:
       {
         return new String[] {
           getDisplay(member, false), simpleTypeName, eeValue,
         };
       }
     case IReference.T_FIELD_REFERENCE:
       {
         return new String[] {
           getDisplay(member, false), simpleTypeName,
           reference.getReferencedMemberName(), eeValue,
         };
       }
     case IReference.T_METHOD_REFERENCE:
       {
         String referenceMemberName = reference.getReferencedMemberName();
         if (Util.isConstructor(referenceMemberName)) {
           return new String[] {
             getDisplay(member, false),
             Signature.toString(
                 reference.getReferencedSignature(), simpleTypeName, null, false, false),
             eeValue,
           };
         } else {
           return new String[] {
             getDisplay(member, false),
             simpleTypeName,
             Signature.toString(
                 reference.getReferencedSignature(), referenceMemberName, null, false, false),
             eeValue,
           };
         }
       }
     default:
       break;
   }
   return null;
 }
Exemple #17
0
 protected void toStringInfo(int tab, StringBuffer buffer, Object info, boolean showResolvedInfo) {
   buffer.append(tabString(tab));
   if (info != NO_INFO) {
     buffer.append(Signature.toString(getTypeSignature()));
     buffer.append(" "); // $NON-NLS-1$
   }
   toStringName(buffer);
 }
 private boolean checkParameters(
     char[] methodDescriptor,
     char[][] parameterSimpleNames,
     char[][] parameterQualifications,
     boolean isCaseSensitive,
     boolean isCamelCase) {
   char[][] arguments = Signature.getParameterTypes(methodDescriptor);
   int parameterCount = parameterSimpleNames.length;
   if (parameterCount != arguments.length) return false;
   for (int i = 0; i < parameterCount; i++)
     if (!checkTypeName(
         parameterSimpleNames[i],
         parameterQualifications[i],
         Signature.toCharArray(arguments[i]),
         isCaseSensitive,
         isCamelCase)) return false;
   return true;
 }
  public Object convertToObject(String parameterValue) throws ParameterValueConversionException {

    assertWellFormed(parameterValue != null);

    final int projectEndPosition = parameterValue.indexOf(PROJECT_END_CHAR);
    assertWellFormed(projectEndPosition != -1);

    String projectName = parameterValue.substring(0, projectEndPosition);
    String javaElementRef = parameterValue.substring(projectEndPosition + 1);

    IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
    assertExists(javaModel);

    IJavaProject javaProject = javaModel.getJavaProject(projectName);
    assertExists(javaProject);

    final int typeEndPosition = javaElementRef.indexOf(TYPE_END_CHAR);
    String typeName;
    if (typeEndPosition == -1) {
      typeName = javaElementRef;
    } else {
      typeName = javaElementRef.substring(0, typeEndPosition);
    }

    IType type = null;
    try {
      type = javaProject.findType(typeName);
    } catch (JavaModelException ex) {
      // type == null
    }
    assertExists(type);

    if (typeEndPosition == -1) {
      return type;
    }

    String memberRef = javaElementRef.substring(typeEndPosition + 1);

    final int paramStartPosition = memberRef.indexOf(PARAM_START_CHAR);
    if (paramStartPosition == -1) {
      IField field = type.getField(memberRef);
      assertExists(field);
      return field;
    }
    String methodName = memberRef.substring(0, paramStartPosition);
    String signature = memberRef.substring(paramStartPosition);
    String[] parameterTypes = null;
    try {
      parameterTypes = Signature.getParameterTypes(signature);
    } catch (IllegalArgumentException ex) {
      // parameterTypes == null
    }
    assertWellFormed(parameterTypes != null);
    IMethod method = type.getMethod(methodName, parameterTypes);
    assertExists(method);
    return method;
  }
  private void addImports(final ICompilationUnit unit, ClipboardData data) throws CoreException {
    final ImportRewrite rewrite = StubUtility.createImportRewrite(unit, true);
    String[] imports = data.getTypeImports();
    for (int i = 0; i < imports.length; i++) {
      rewrite.addImport(imports[i]);
    }
    String[] staticImports = data.getStaticImports();
    for (int i = 0; i < staticImports.length; i++) {
      String name = Signature.getSimpleName(staticImports[i]);
      boolean isField = !name.endsWith("()"); // $NON-NLS-1$
      if (!isField) {
        name = name.substring(0, name.length() - 2);
      }
      String qualifier = Signature.getQualifier(staticImports[i]);
      rewrite.addStaticImport(qualifier, name, isField);
    }

    try {
      getProgressService()
          .busyCursorWhile(
              new IRunnableWithProgress() {
                public void run(IProgressMonitor monitor)
                    throws InvocationTargetException, InterruptedException {
                  try {
                    JavaModelUtil.applyEdit(unit, rewrite.rewriteImports(monitor), false, null);
                  } catch (CoreException e) {
                    throw new InvocationTargetException(e);
                  }
                }
              });
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      if (cause instanceof CoreException) throw (CoreException) cause;
      throw new CoreException(
          new Status(
              IStatus.ERROR,
              JavaUI.ID_PLUGIN,
              IJavaStatusConstants.INTERNAL_ERROR,
              JavaUIMessages.JavaPlugin_internal_error,
              cause));
    } catch (InterruptedException e) {
      // Canceled by the user
    }
  }
Exemple #21
0
 public static String getType(final IField field) {
   try {
     return Signature.toString(field.getTypeSignature());
   } catch (final IllegalArgumentException e) {
     e.printStackTrace();
   } catch (final JavaModelException e) {
     e.printStackTrace();
   }
   return null;
 }
  /**
   * Takes a method signature <code>
   * [&lt; typeVariableName : formalTypeDecl &gt;] ( paramTypeSig1* ) retTypeSig</code> and returns
   * it with any parameter signatures filtered through <code>getLowerBound</code> and the return
   * type filtered through <code>getUpperBound</code>. Any preceding formal type variable
   * declarations are removed.
   *
   * <p>TODO this is a temporary workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=83600
   *
   * @param signature the method signature to convert
   * @return the signature with no bounded types
   */
  public static char[] unboundedSignature(char[] signature) {
    if (signature == null || signature.length < 2) return signature;

    final boolean BUG_83600 = true;
    // XXX the signatures from CompletionRequestor contain a superfluous '+'
    // before type parameters to parameter types
    if (BUG_83600) {
      signature = fix83600(signature);
    }

    StringBuffer res = new StringBuffer("("); // $NON-NLS-1$
    char[][] parameters = Signature.getParameterTypes(signature);
    for (int i = 0; i < parameters.length; i++) {
      char[] param = parameters[i];
      res.append(getLowerBound(param));
    }
    res.append(')');
    res.append(getUpperBound(Signature.getReturnType(signature)));
    return res.toString().toCharArray();
  }
  /*
   * @see org.eclipse.jdt.internal.ui.text.java.LazyJavaCompletionProposal#computeContextInformation()
   * @since 3.3
   */
  @Override
  protected IContextInformation computeContextInformation() {
    char[] signature = fProposal.getSignature();
    char[][] typeParameters = Signature.getTypeArguments(signature);
    if (typeParameters.length == 0) return super.computeContextInformation();

    ProposalContextInformation contextInformation = new ProposalContextInformation(fProposal);
    if (fContextInformationPosition != 0 && fProposal.getCompletion().length == 0)
      contextInformation.setContextInformationPosition(fContextInformationPosition);
    return contextInformation;
  }
  private static void appendMethodReference(IMethod meth, StringBuffer buf)
      throws JavaModelException {
    buf.append(meth.getElementName());

    /*
     * The Javadoc tool for Java SE 8 changed the anchor syntax and now tries to avoid "strange" characters in URLs.
     * This breaks all clients that directly create such URLs.
     * We can't know what format is required, so we just guess by the project's compiler compliance.
     */
    boolean is18OrHigher = JavaModelUtil.is18OrHigher(meth.getJavaProject());
    buf.append(is18OrHigher ? '-' : '(');
    String[] params = meth.getParameterTypes();
    IType declaringType = meth.getDeclaringType();
    boolean isVararg = Flags.isVarargs(meth.getFlags());
    int lastParam = params.length - 1;
    for (int i = 0; i <= lastParam; i++) {
      if (i != 0) {
        buf.append(is18OrHigher ? "-" : ", "); // $NON-NLS-1$ //$NON-NLS-2$
      }
      String curr = Signature.getTypeErasure(params[i]);
      String fullName = JavaModelUtil.getResolvedTypeName(curr, declaringType);
      if (fullName == null) { // e.g. a type parameter "QE;"
        fullName = Signature.toString(Signature.getElementType(curr));
      }
      if (fullName != null) {
        buf.append(fullName);
        int dim = Signature.getArrayCount(curr);
        if (i == lastParam && isVararg) {
          dim--;
        }
        while (dim > 0) {
          buf.append(is18OrHigher ? ":A" : "[]"); // $NON-NLS-1$ //$NON-NLS-2$
          dim--;
        }
        if (i == lastParam && isVararg) {
          buf.append("..."); // $NON-NLS-1$
        }
      }
    }
    buf.append(is18OrHigher ? '-' : ')');
  }
Exemple #25
0
 public void computeParameterizedTypeName(String signature, StringBuilder uriBuilder) {
   computeTypeName(signature, uriBuilder);
   String[] typeArguments = Signature.getTypeArguments(signature);
   if (typeArguments.length != 0) {
     uriBuilder.append('<');
     for (int i = 0; i < typeArguments.length; i++) {
       if (i != 0) uriBuilder.append(',');
       computeParameter(typeArguments[i], uriBuilder);
     }
     uriBuilder.append('>');
   }
 }
  boolean matchMethod(MethodPattern pattern, Object binaryInfo, IBinaryType enclosingBinaryType) {
    if (!pattern.findDeclarations) return false; // only relevant when finding declarations
    if (!(binaryInfo instanceof IBinaryMethod)) return false;

    IBinaryMethod method = (IBinaryMethod) binaryInfo;
    if (!pattern.matchesName(pattern.selector, method.getSelector())) return false;
    if (!checkDeclaringType(
        enclosingBinaryType,
        pattern.declaringSimpleName,
        pattern.declaringQualification,
        pattern.isCaseSensitive(),
        pattern.isCamelCase())) return false;

    // look at return type only if declaring type is not specified
    boolean checkReturnType =
        pattern.declaringSimpleName == null
            && (pattern.returnSimpleName != null || pattern.returnQualification != null);
    boolean checkParameters = pattern.parameterSimpleNames != null;
    if (checkReturnType || checkParameters) {
      char[] methodDescriptor = convertClassFileFormat(method.getMethodDescriptor());
      if (checkReturnType) {
        char[] returnTypeSignature =
            Signature.toCharArray(Signature.getReturnType(methodDescriptor));
        if (!checkTypeName(
            pattern.returnSimpleName,
            pattern.returnQualification,
            returnTypeSignature,
            pattern.isCaseSensitive(),
            pattern.isCamelCase())) return false;
      }
      if (checkParameters
          && !checkParameters(
              methodDescriptor,
              pattern.parameterSimpleNames,
              pattern.parameterQualifications,
              pattern.isCaseSensitive(),
              pattern.isCamelCase())) return false;
    }
    return true;
  }
  /**
   * Create a {@link BeansJavaCompletionProposal} for the given {@link IMethod} and report it on the
   * {@link ContentAssistRequest}.
   */
  protected void createMethodProposal(IContentAssistProposalRecorder recorder, IMethod method) {
    try {
      String[] parameterNames = method.getParameterNames();
      String[] parameterTypes = JdtUtils.getParameterTypesString(method);
      String returnType = JdtUtils.getReturnTypeString(method, true);
      String methodName = JdtUtils.getMethodName(method);

      String replaceText = methodName;

      StringBuilder buf = new StringBuilder();

      // add method name
      buf.append(replaceText);

      // add method parameters
      if (parameterTypes.length > 0 && parameterNames.length > 0) {
        buf.append(" (");
        for (int i = 0; i < parameterTypes.length; i++) {
          buf.append(parameterTypes[i]);
          buf.append(' ');
          buf.append(parameterNames[i]);
          if (i < (parameterTypes.length - 1)) {
            buf.append(", ");
          }
        }
        buf.append(") ");
      } else {
        buf.append("() ");
      }

      // add return type
      if (returnType != null) {
        buf.append(Signature.getSimpleName(returnType));
        buf.append(" - ");
      } else {
        buf.append(" void - ");
      }

      // add class name
      buf.append(JdtUtils.getParentName(method));

      String displayText = buf.toString();
      Image image =
          Activator.getDefault()
              .getJavaElementLabelProvider()
              .getImageLabel(method, method.getFlags() | JavaElementImageProvider.SMALL_ICONS);

      recorder.recordProposal(image, METHOD_RELEVANCE, displayText, replaceText, method);
    } catch (JavaModelException e) {
      // do nothing
    }
  }
  private ISymbol internalCreateFromBaseType(
      String symbolName, ValueType valueType, IJavaProject javaProject) {
    // based on JSF 1.1 spec section 4.2.1.4 the data model
    // value binding can be one of a number of object that will
    // get an implicit DataModel wrapper at runtime

    // could be an array
    if (Signature.getArrayCount(valueType.getSignature()) > 0) {
      return getSymbolFactory()
          .createArraySymbol(
              symbolName,
              valueType.getSignature(),
              ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL,
              javaProject);
    }

    // if is a list, then we have extra work to do if it
    // is generic and has info about its contents
    if (valueType.isInstanceOf(TypeConstants.TYPE_LIST)) {
      return getSymbolFactory()
          .createFromList(
              symbolName,
              valueType,
              ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL,
              null,
              javaProject);
    }
    // if is JSTL ResultSet, java ResultSet or DataModel
    // return the default symbol -- in the absence of definite
    // template info, these row containers are opaque to us
    else if (valueType.isInstanceOf(TypeConstants.TYPE_JAVAX_SERVLET_JSP_JSTL_SQL_RESULT)
        || valueType.isInstanceOf(TypeConstants.TYPE_RESULT_SET)
        || valueType.isInstanceOf(TypeConstants.TYPE_DATA_MODEL)) {
      return getSymbolFactory()
          .createDefaultSymbol(
              symbolName,
              ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL,
              Messages.getString(
                  "AbstractDataModelVariableFactory.DataModel.Symbol.RowVariable.DetailedDescription")); //$NON-NLS-1$
    }

    // in other cases, we assume that the value is an explicit single row
    // scalar object
    return getSymbolFactory()
        .createScalarSymbol(
            symbolName,
            valueType.getSignature(),
            ERuntimeSource.TAG_INSTANTIATED_SYMBOL_LITERAL,
            javaProject);
  }
 /**
  * Builds a string of the constructor parameters.
  *
  * @param type The type containing the fields.
  * @param fields The array of fields.
  * @return The parameters string.
  */
 protected String buildParams(IType type, String[] fields) throws Exception {
   StringBuffer params = new StringBuffer();
   for (int ii = 0; ii < fields.length; ii++) {
     if (ii != 0) {
       params.append(", ");
     }
     IField field = type.getField(fields[ii]);
     params
         .append(Signature.getSignatureSimpleName(field.getTypeSignature()))
         .append(' ')
         .append(field.getElementName());
   }
   return params.toString();
 }
Exemple #30
0
 /**
  * Determines is the java element contains a specific method.
  *
  * <p>The syntax for the property tester is of the form: methodname, signature, modifiers.
  *
  * <ol>
  *   <li>methodname - case sensitive method name, required. For example, <code>toString</code>.
  *   <li>signature - JLS style method signature, required. For example, <code>(QString;)V</code>.
  *   <li>modifiers - optional space separated list of modifiers, for example, <code>public static
  *       </code>.
  * </ol>
  *
  * @param element the element to check for the method
  * @param args first arg is method name, secondary args are parameter types signatures
  * @return true if the method is found in the element, false otherwise
  */
 private boolean hasMethod(IJavaElement element, Object[] args) {
   try {
     if (args.length > 1) {
       IType type = getType(element);
       if (type != null && type.exists()) {
         String name = (String) args[0];
         String signature = (String) args[1];
         String[] parms = Signature.getParameterTypes(signature);
         String returnType = Signature.getReturnType(signature);
         IMethod candidate = type.getMethod(name, parms);
         if (candidate.exists()) {
           // check return type
           if (candidate.getReturnType().equals(returnType)) {
             // check modifiers
             if (args.length > 2) {
               String modifierText = (String) args[2];
               String[] modifiers = modifierText.split(" "); // $NON-NLS-1$
               int flags = 0;
               for (int j = 0; j < modifiers.length; j++) {
                 String modifier = modifiers[j];
                 Integer flag = (Integer) fgModifiers.get(modifier);
                 if (flag != null) {
                   flags = flags | flag.intValue();
                 }
               }
               if (candidate.getFlags() == flags) {
                 return true;
               }
             }
           }
         }
       }
     }
   } catch (JavaModelException e) {
   }
   return false;
 }