Example usage for org.eclipse.jdt.internal.compiler.lookup TypeBinding qualifiedPackageName

List of usage examples for org.eclipse.jdt.internal.compiler.lookup TypeBinding qualifiedPackageName

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.internal.compiler.lookup.*
  5. TypeBinding
  6. qualifiedPackageName

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.lookup TypeBinding qualifiedPackageName.

Prototype


public char[] qualifiedPackageName()

Source Link

Document

Answer the qualified name of the receiver's package separated by periods or an empty string if its the default package.

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.search.matching.PatternLocator.java

License:Open Source License

/**
 * Returns whether the given type binding matches the given qualified pattern.
 * Returns ACCURATE_MATCH if it does./*  w w  w .j  ava 2  s  . c  om*/
 * Returns INACCURATE_MATCH if resolve failed.
 * Returns IMPOSSIBLE_MATCH if it doesn't.
 */
protected int resolveLevelForType(char[] qualifiedPattern, TypeBinding type) {
    if (qualifiedPattern == null)
        return ACCURATE_MATCH;
    if (type == null || !type.isValidBinding())
        return INACCURATE_MATCH;

    // Type variable cannot be specified through pattern => this kind of binding cannot match it (see bug 79803)
    if (type.isTypeVariable())
        return IMPOSSIBLE_MATCH;

    // NOTE: if case insensitive search then qualifiedPattern is assumed to be lowercase

    char[] qualifiedPackageName = type.qualifiedPackageName();
    char[] qualifiedSourceName = qualifiedSourceName(type);
    char[] fullyQualifiedTypeName = qualifiedPackageName.length == 0 ? qualifiedSourceName
            : CharOperation.concat(qualifiedPackageName, qualifiedSourceName, '.');
    return CharOperation.match(qualifiedPattern, fullyQualifiedTypeName, this.isCaseSensitive) ? ACCURATE_MATCH
            : IMPOSSIBLE_MATCH;
}

From source file:com.google.gwt.dev.javac.JdtUtil.java

License:Apache License

public static String getSourceName(TypeBinding classBinding) {
    return Joiner.on(".").skipNulls()
            .join(new String[] {
                    Strings.emptyToNull(CharOperation.charToString(classBinding.qualifiedPackageName())),
                    CharOperation.charToString(classBinding.qualifiedSourceName()) });
}

From source file:com.redhat.ceylon.eclipse.core.model.loader.JDTUtils.java

License:Open Source License

public static String getFullyQualifiedName(TypeBinding type) {
    StringBuilder builder = new StringBuilder();
    char[] packageName = type.qualifiedPackageName();
    if (packageName != CharOperation.NO_CHAR) {
        builder.append(packageName).append('.');
    }//from   www .j ava2 s.c  o  m
    return builder.append(type.qualifiedSourceName()).toString();
}

From source file:lombok.eclipse.agent.ExtensionMethodCompletionProposal.java

License:Open Source License

public void setMethodBinding(final MethodBinding method, final ASTNode node) {
    MethodBinding original = method.original();
    TypeBinding[] parameters = Arrays.copyOf(method.parameters, method.parameters.length);
    method.parameters = Arrays.copyOfRange(method.parameters, 1, method.parameters.length);
    TypeBinding[] originalParameters = null;
    if (original != method) {
        originalParameters = Arrays.copyOf(method.original().parameters, method.original().parameters.length);
        method.original().parameters = Arrays.copyOfRange(method.original().parameters, 1,
                method.original().parameters.length);
    }//ww w  .  j  a v  a  2 s .  co  m

    int length = method.parameters == null ? 0 : method.parameters.length;
    char[][] parameterPackageNames = new char[length][];
    char[][] parameterTypeNames = new char[length][];

    for (int i = 0; i < length; i++) {
        TypeBinding type = method.original().parameters[i];
        parameterPackageNames[i] = type.qualifiedPackageName();
        parameterTypeNames[i] = type.qualifiedSourceName();
    }
    char[] completion = CharOperation.concat(method.selector, new char[] { '(', ')' });
    setDeclarationSignature(CompletionEngine.getSignature(method.declaringClass));
    setSignature(CompletionEngine.getSignature(method));

    if (original != method) {
        setOriginalSignature(CompletionEngine.getSignature(original));
    }
    setDeclarationPackageName(method.declaringClass.qualifiedPackageName());
    setDeclarationTypeName(method.declaringClass.qualifiedSourceName());
    setParameterPackageNames(parameterPackageNames);
    setParameterTypeNames(parameterTypeNames);
    setPackageName(method.returnType.qualifiedPackageName());
    setTypeName(method.returnType.qualifiedSourceName());
    setName(method.selector);
    setCompletion(completion);
    setFlags(method.modifiers & (~AccStatic));
    int index = node.sourceEnd + 1;
    if (node instanceof CompletionOnQualifiedNameReference) {
        index -= ((CompletionOnQualifiedNameReference) node).completionIdentifier.length;
    }
    if (node instanceof CompletionOnMemberAccess) {
        index -= ((CompletionOnMemberAccess) node).token.length;
    }
    if (node instanceof CompletionOnSingleNameReference) {
        index -= ((CompletionOnSingleNameReference) node).token.length;
    }
    setReplaceRange(index, index);
    setTokenRange(index, index);

    setRelevance(100);

    method.parameters = parameters;
    if (original != method) {
        method.original().parameters = originalParameters;
    }
}

From source file:lombok.eclipse.agent.PatchDelegate.java

License:Open Source License

private static boolean isDelegate(Annotation ann, TypeDeclaration decl) {
    if (ann.type == null)
        return false;
    TypeBinding tb = ann.type.resolveType(decl.initializerScope);
    if (tb == null)
        return false;
    if (!charArrayEquals("lombok", tb.qualifiedPackageName())
            && !charArrayEquals("lombok.experimental", tb.qualifiedPackageName()))
        return false;
    if (!charArrayEquals("Delegate", tb.qualifiedSourceName()))
        return false;
    return true;//from  w  ww . ja  v a 2  s .  co m
}

From source file:lombok.eclipse.agent.PatchDelegate.java

License:Open Source License

private static String typeBindingToSignature(TypeBinding binding) {
    binding = binding.erasure();/*from w w w  .  j  ava2  s. c o  m*/
    if (binding != null && binding.isBaseType()) {
        return new String(binding.sourceName());
    } else if (binding instanceof ReferenceBinding) {
        String pkg = binding.qualifiedPackageName() == null ? "" : new String(binding.qualifiedPackageName());
        String qsn = binding.qualifiedSourceName() == null ? "" : new String(binding.qualifiedSourceName());
        return pkg.isEmpty() ? qsn : (pkg + "." + qsn);
    } else if (binding instanceof ArrayBinding) {
        StringBuilder out = new StringBuilder();
        out.append(typeBindingToSignature(binding.leafComponentType()));
        for (int i = 0; i < binding.dimensions(); i++)
            out.append("[]");
        return out.toString();
    }

    return "";
}

From source file:lombok.eclipse.agent.PatchExtensionMethod.java

License:Open Source License

private static NameReference createNameRef(TypeBinding typeBinding, ASTNode source) {
    long p = ((long) source.sourceStart << 32) | source.sourceEnd;
    char[] pkg = typeBinding.qualifiedPackageName();
    char[] basename = typeBinding.qualifiedSourceName();

    StringBuilder sb = new StringBuilder();
    if (pkg != null)
        sb.append(pkg);/*  w  w w  .j  a  v  a 2 s. c  om*/
    if (sb.length() > 0)
        sb.append(".");
    sb.append(basename);

    String tName = sb.toString();

    if (tName.indexOf('.') == -1) {
        return new SingleNameReference(basename, p);
    } else {
        char[][] sources;
        String[] in = tName.split("\\.");
        sources = new char[in.length][];
        for (int i = 0; i < in.length; i++)
            sources[i] = in[i].toCharArray();
        long[] poss = new long[in.length];
        Arrays.fill(poss, p);
        return new QualifiedNameReference(sources, poss, source.sourceStart, source.sourceEnd);
    }
}

From source file:lombok.eclipse.agent.PatchVal.java

License:Open Source License

private static boolean isVal(TypeReference ref, BlockScope scope) {
    if (!couldBeVal(ref))
        return false;

    TypeBinding resolvedType = ref.resolvedType;
    if (resolvedType == null)
        resolvedType = ref.resolveType(scope, false);
    if (resolvedType == null)
        return false;

    char[] pkg = resolvedType.qualifiedPackageName();
    char[] nm = resolvedType.qualifiedSourceName();
    return matches("lombok", pkg) && matches("val", nm);
}

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;// www  . j a va  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:lombok.eclipse.handlers.HandleActionFunctionAndPredicate.java

License:Open Source License

private String qualifiedName(final TypeBinding typeBinding) {
    String qualifiedName = As.string(typeBinding.qualifiedPackageName());
    if (!qualifiedName.isEmpty())
        qualifiedName += ".";
    qualifiedName += As.string(typeBinding.qualifiedSourceName());
    return qualifiedName;
}