Example usage for org.eclipse.jdt.core Signature removeCapture

List of usage examples for org.eclipse.jdt.core Signature removeCapture

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. Signature
  6. removeCapture

Introduction

In this page you can find the example usage for org.eclipse.jdt.core Signature removeCapture.

Prototype

public static String removeCapture(String methodOrTypeSignature)

Source Link

Document

Removes any capture information from the given type or method signature and returns the resulting signature.

Usage

From source file:at.bestsolution.fxide.jdt.editor.internal.SignatureUtil.java

License:Open Source License

/**
 * TODO this is a temporary workaround for
 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=83600 and
 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=85293
 *
 * @param signature the method signature to convert
 * @return the fixed signature//from ww  w  . ja  v a2  s .  co m
 */
public static char[] fix83600(char[] signature) {
    if (signature == null || signature.length < 2)
        return signature;

    return Signature.removeCapture(signature);
}

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

/**
 * Split signatures of all levels from a type unique key.
 * <p/>//from   w w  w.  ja v  a  2  s . com
 * Example: For following type X<Y<Z>,V<W>,U>.A<B>, unique key is: "LX<LY<LZ;>;LV<LW;>;LU;>.LA<LB;>;"
 * <p/>
 * The return splitted signatures array is: [ ['L','X','<','L','Y','<','L','Z'
 * ,';'>',';','L','V','<','L','W',';'>',';','L','U','>',';'], ['L','A','<','L','B',';','>',';']
 *
 * @param typeSignature
 *         ParameterizedSourceType type signature
 * @return char[][] Array of signatures for each level of given unique key
 */
public final static char[][] splitTypeLevelsSignature(String typeSignature) {
    // In case of IJavaElement signature, replace '$' by '.'
    char[] source = Signature.removeCapture(typeSignature.toCharArray());
    CharOperation.replace(source, '$', '.');

    // Init counters and arrays
    char[][] signatures = new char[10][];
    int signaturesCount = 0;
    // int[] lengthes = new int [10];
    int paramOpening = 0;

    // Scan each signature character
    for (int idx = 0, ln = source.length; idx < ln; idx++) {
        switch (source[idx]) {
        case '>':
            paramOpening--;
            if (paramOpening == 0) {
                if (signaturesCount == signatures.length) {
                    System.arraycopy(signatures, 0, signatures = new char[signaturesCount + 10][], 0,
                            signaturesCount);
                }
            }
            break;
        case '<':
            paramOpening++;
            break;
        case '.':
            if (paramOpening == 0) {
                if (signaturesCount == signatures.length) {
                    System.arraycopy(signatures, 0, signatures = new char[signaturesCount + 10][], 0,
                            signaturesCount);
                }
                signatures[signaturesCount] = new char[idx + 1];
                System.arraycopy(source, 0, signatures[signaturesCount], 0, idx);
                signatures[signaturesCount][idx] = Signature.C_SEMICOLON;
                signaturesCount++;
            }
            break;
        case '/':
            source[idx] = '.';
            break;
        }
    }

    // Resize signatures array
    char[][] typeSignatures = new char[signaturesCount + 1][];
    typeSignatures[0] = source;
    for (int i = 1, j = signaturesCount - 1; i <= signaturesCount; i++, j--)//NOSONAR
    {
        typeSignatures[i] = signatures[j];
    }
    return typeSignatures;
}

From source file:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * Resolve typeSignature in the context of owningType.  This method will return 
 * a type erased signture if eraseTypeParameters == true and will attempt to
 * resolve and include parameters if eraseTypeParamters == false
 * /* w w  w. jav  a2 s . c o m*/
 * NOTE: special rules apply to the way unresolved type parameters and wildcards
 * are resolved:
 * 
 * 1) If a fully unresolved type parameter is found, then it will be replaced with Ljava.lang.Object;
 * 
 * i.e.  List<T>  -> Ljava.util.List<Ljava.lang.Object;>;  for any unresolved T.
 * 
 * 2) Any bounded wildcard will be replaced by the bound:
 * 
 * i.e. List<? extends String> -> Ljava.util.List<Ljava.lang.String;>;
 * i.e. List<? super String> -> Ljava.util.List<Ljava.lang.String;>;
 * 
 * Note limitation here: bounds that use 'super' will take the "best case" scenario that the list
 * type is of that type.
 * 
 * 3) The unbounded wildcard will be replaced by Ljava.lang.Object;
 * 
 * i.e. List<?> -> Ljava.util.List<Ljava.lang.Object;>;
 * 
 * 
 * The reason for this substition is to return the most accurate reasonable approximation
 * of the type within what is known by owningType
 * 
 * @param owningType
 * @param typeSignature
 * @param eraseTypeParameters if set to false, type parameters are resolved included
 * in the signature
 * @return the resolved type signature for typeSignature in owningType or
 * typeSignature unchanged if cannot resolve.
 */
public static String resolveTypeSignature(final IType owningType, final String typeSignature,
        boolean eraseTypeParameters) {
    final int sigKind = Signature.getTypeSignatureKind(typeSignature);

    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        return typeSignature;

    case Signature.ARRAY_TYPE_SIGNATURE: {
        final String elementType = Signature.getElementType(typeSignature);

        if (Signature.getTypeSignatureKind(elementType) == Signature.BASE_TYPE_SIGNATURE) {
            return typeSignature;
        }

        final String resolvedElementType = resolveSignatureRelative(owningType, elementType,
                eraseTypeParameters);
        String resultType = ""; //$NON-NLS-1$
        for (int i = 0; i < Signature.getArrayCount(typeSignature); i++) {
            resultType += Signature.C_ARRAY;
        }

        return resultType + resolvedElementType;
    }

    case Signature.TYPE_VARIABLE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.CLASS_TYPE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.WILDCARD_TYPE_SIGNATURE:
        // strip the wildcard and try again.  Too bad Signature doesn't seem to have a method
        // for this
        if (typeSignature.charAt(0) == Signature.C_STAR) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
        return resolveTypeSignature(owningType, typeSignature.substring(1), eraseTypeParameters);

    case Signature.CAPTURE_TYPE_SIGNATURE:
        // strip the capture and try again
        return resolveTypeSignature(owningType, Signature.removeCapture(typeSignature), eraseTypeParameters);
    //      case Signature.TYPE_VARIABLE_SIGNATURE:
    //      resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    default:
        return typeSignature;
    }
}

From source file:com.google.inject.tools.ideplugin.eclipse.TypeUtil.java

License:Open Source License

/**
 * @param owningType -- type relative to which typeSignature will be resolved
 * @param typeSignature -- non-array type signature
 * @return the resolved type signature if possible or typeSignature if not
 *///from w ww .  j a va2  s . c  o m
private static String resolveSignatureRelative(final IType owningType, final String typeSignature,
        final boolean eraseTypeParameters) {
    // if already fully resolved, return the input
    if (typeSignature.charAt(0) == Signature.C_RESOLVED) {
        return typeSignature;
    }

    List<String> typeParameters = new ArrayList<String>();

    IType resolvedType = resolveTypeRelative(owningType, typeSignature);

    if (resolvedType != null) {
        if (!eraseTypeParameters) {
            // ensure that type parameters are resolved recursively
            for (String typeParam : Signature.getTypeArguments(typeSignature)) {
                typeParam = Signature.removeCapture(typeParam);
                // check and remove bound wildcarding (extends/super/?)
                if (Signature.getTypeSignatureKind(typeParam) == Signature.WILDCARD_TYPE_SIGNATURE) {
                    // convert ? to Object, strip extends/super
                    if (typeParam.charAt(0) == Signature.C_STAR) {
                        typeParam = TypeConstants.TYPE_JAVAOBJECT;
                    } else {
                        typeParam = typeParam.substring(1);
                    }
                }
                final String resolvedParameter = resolveSignatureRelative(
                        // use the enclosing type, 
                        // *not* the resolved type because 
                        // we need to resolve in that context
                        owningType, typeParam, eraseTypeParameters);
                typeParameters.add(resolvedParameter);
            }
        }

        final String resolvedTypeSignature = Signature.createTypeSignature(resolvedType.getFullyQualifiedName(),
                true);

        if (typeParameters.size() > 0 && !eraseTypeParameters) {
            StringBuffer sb = new StringBuffer(resolvedTypeSignature);

            if (sb.charAt(sb.length() - 1) == ';') {
                sb = sb.delete(sb.length() - 1, sb.length());
            }

            sb.append("<"); //$NON-NLS-1$
            for (String param : typeParameters) {
                //System.out.println("type param: "+resolvedType.getTypeParameter(param));
                sb.append(param);
            }

            // replace the dangling ',' with the closing ">"
            sb.append(">;"); //$NON-NLS-1$
            return sb.toString();
        }

        return resolvedTypeSignature;
    }

    if (Signature.getTypeSignatureKind(typeSignature) == Signature.CLASS_TYPE_SIGNATURE
            || Signature.getTypeSignatureKind(typeSignature) == Signature.TYPE_VARIABLE_SIGNATURE) {
        // if we are unable to resolve, check to see if the owning type has
        // a parameter by this name
        ITypeParameter typeParam = owningType.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));

        // if we have a type parameter and it hasn't been resolved to a type,
        // then assume it is a method template placeholder (i.e. T in ArrayList).
        // at runtime these unresolved parameter variables are effectively 
        // turned into Object's.  For example, think List.add(E o).  At runtime,
        // E will behave exactly like java.lang.Object in that signature
        if (typeParam.exists()) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
    }

    return typeSignature;
}

From source file:org.eclipse.jst.jsf.common.util.TypeUtil.java

License:Open Source License

/**
 * Resolve typeSignature in the context of owningType.  This method will return 
 * a type erased signture if eraseTypeParameters == true and will attempt to
 * resolve and include parameters if eraseTypeParamters == false
 * /*from   ww w .  j  a  v  a  2 s . c o m*/
 * NOTE: special rules apply to the way unresolved type parameters and wildcards
 * are resolved:
 * 
 * 1) If a fully unresolved type parameter is found, then it will be replaced with Ljava.lang.Object;
 * 
 * i.e.  List<T>  -> Ljava.util.List<Ljava.lang.Object;>;  for any unresolved T.
 * 
 * 2) Any bounded wildcard will be replaced by the bound:
 * 
 * i.e. List<? extends String> -> Ljava.util.List<Ljava.lang.String;>;
 * i.e. List<? super String> -> Ljava.util.List<Ljava.lang.String;>;
 * 
 * Note limitation here: bounds that use 'super' will take the "best case" scenario that the list
 * type is of that type.
 * 
 * 3) The unbounded wildcard will be replaced by Ljava.lang.Object;
 * 
 * i.e. List<?> -> Ljava.util.List<Ljava.lang.Object;>;
 * 
 * 
 * The reason for this substition is to return the most accurate reasonable approximation
 * of the type within what is known by owningType
 * 
 * @param owningType
 * @param typeSignature
 * @param eraseTypeParameters if set to false, type parameters are resolved included
 * in the signature
 * @return the resolved type signature for typeSignature in owningType or
 * typeSignature unchanged if cannot resolve.
 */
public static String resolveTypeSignature(final IType owningType, final String typeSignature,
        boolean eraseTypeParameters) {
    final int sigKind = Signature.getTypeSignatureKind(typeSignature);

    switch (sigKind) {
    case Signature.BASE_TYPE_SIGNATURE:
        return typeSignature;

    case Signature.ARRAY_TYPE_SIGNATURE: {
        final String elementType = Signature.getElementType(typeSignature);

        if (Signature.getTypeSignatureKind(elementType) == Signature.BASE_TYPE_SIGNATURE) {
            return typeSignature;
        }

        final String resolvedElementType = resolveSignatureRelative(owningType, elementType,
                eraseTypeParameters);
        String resultType = ""; //$NON-NLS-1$
        for (int i = 0; i < Signature.getArrayCount(typeSignature); i++) {
            resultType += Signature.C_ARRAY;
        }

        return resultType + resolvedElementType;
    }

    case Signature.TYPE_VARIABLE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.CLASS_TYPE_SIGNATURE:
        return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    case Signature.WILDCARD_TYPE_SIGNATURE:
        // strip the wildcard and try again.  Too bad Signature doesn't seem to have a method
        // for this
        if (typeSignature.charAt(0) == Signature.C_STAR) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }
        return resolveTypeSignature(owningType, typeSignature.substring(1), eraseTypeParameters);

    case Signature.CAPTURE_TYPE_SIGNATURE:
        // strip the capture and try again
        return resolveTypeSignature(owningType, Signature.removeCapture(typeSignature), eraseTypeParameters);
    //            case Signature.TYPE_VARIABLE_SIGNATURE:
    //                resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);

    default:
        return typeSignature;
    }
}

From source file:org.eclipse.jst.jsf.common.util.TypeUtil.java

License:Open Source License

/**
 * @param owningType -- type relative to which typeSignature will be resolved
 * @param typeSignature -- non-array type signature
 * @return the resolved type signature if possible or typeSignature if not
 */// w w w  .  j a v  a2s . c  o  m
private static String resolveSignatureRelative(final IType owningType, final String typeSignature,
        final boolean eraseTypeParameters) {
    // if already fully resolved, return the input
    if (typeSignature.charAt(0) == Signature.C_RESOLVED) {
        return typeSignature;
    }

    List<String> typeParameters = new ArrayList<String>();

    IType resolvedType = resolveTypeRelative(owningType, typeSignature);

    if (resolvedType != null) {
        if (!eraseTypeParameters) {
            // ensure that type parameters are resolved recursively
            for (String typeParam : Signature.getTypeArguments(typeSignature)) {
                typeParam = Signature.removeCapture(typeParam);
                // check and remove bound wildcarding (extends/super/?)
                if (Signature.getTypeSignatureKind(typeParam) == Signature.WILDCARD_TYPE_SIGNATURE) {
                    // convert ? to Object, strip extends/super
                    if (typeParam.charAt(0) == Signature.C_STAR) {
                        typeParam = TypeConstants.TYPE_JAVAOBJECT;
                    } else {
                        typeParam = typeParam.substring(1);
                    }
                }
                final String resolvedParameter = resolveSignatureRelative(
                        // use the enclosing type, 
                        // *not* the resolved type because 
                        // we need to resolve in that context
                        owningType, typeParam, eraseTypeParameters);
                typeParameters.add(resolvedParameter);
            }
        }

        final String resolvedTypeSignature = Signature.createTypeSignature(resolvedType.getFullyQualifiedName(),
                true);

        if (typeParameters.size() > 0 && !eraseTypeParameters) {
            StringBuffer sb = new StringBuffer(resolvedTypeSignature);

            if (sb.charAt(sb.length() - 1) == ';') {
                sb = sb.delete(sb.length() - 1, sb.length());
            }

            sb.append("<"); //$NON-NLS-1$
            for (String param : typeParameters) {
                //System.out.println("type param: "+resolvedType.getTypeParameter(param));
                sb.append(param);
            }

            // replace the dangling ',' with the closing ">"
            sb.append(">;"); //$NON-NLS-1$
            return sb.toString();
        }

        return resolvedTypeSignature;
    }

    if (Signature.getTypeSignatureKind(typeSignature) == Signature.CLASS_TYPE_SIGNATURE
            || Signature.getTypeSignatureKind(typeSignature) == Signature.TYPE_VARIABLE_SIGNATURE) {
        // if we are unable to resolve, check to see if the owning type has
        // a parameter by this name
        ITypeParameter typeParam = owningType.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));

        // if we have a type parameter and it hasn't been resolved to a type,
        // then assume it is a method template placeholder (i.e. T in ArrayList).
        // at runtime these unresolved parameter variables are effectively 
        // turned into Object's.  For example, think List.add(E o).  At runtime,
        // E will behave exactly like java.lang.Object in that signature
        if (typeParam.exists()) {
            return TypeConstants.TYPE_JAVAOBJECT;
        }

        // TODO: is there a better way to handle a failure to resolve
        // than just garbage out?
        //JSFCommonPlugin.log(new Exception("Failed to resolve type: "+typeSignature), "Failed to resolve type: "+typeSignature); //$NON-NLS-1$ //$NON-NLS-2$
    }

    return typeSignature;
}