| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.gwt.dev.javac; |
| |
| import com.google.gwt.dev.jjs.ast.JDeclaredType; |
| import com.google.gwt.dev.util.Name.InternalName; |
| import com.google.gwt.thirdparty.guava.common.base.Function; |
| import com.google.gwt.thirdparty.guava.common.base.Joiner; |
| import com.google.gwt.thirdparty.guava.common.base.Predicate; |
| import com.google.gwt.thirdparty.guava.common.base.Strings; |
| import com.google.gwt.thirdparty.guava.common.collect.FluentIterable; |
| import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet; |
| import com.google.gwt.thirdparty.guava.common.collect.Iterables; |
| import com.google.gwt.thirdparty.guava.common.collect.Lists; |
| |
| import org.eclipse.jdt.core.compiler.CharOperation; |
| import org.eclipse.jdt.internal.compiler.ast.Annotation; |
| import org.eclipse.jdt.internal.compiler.impl.BooleanConstant; |
| import org.eclipse.jdt.internal.compiler.impl.StringConstant; |
| import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.BaseTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.ClassScope; |
| import org.eclipse.jdt.internal.compiler.lookup.ElementValuePair; |
| import org.eclipse.jdt.internal.compiler.lookup.FieldBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.MethodBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.NestedTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.TypeBinding; |
| import org.eclipse.jdt.internal.compiler.lookup.TypeIds; |
| |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Utility functions to interact with JDT classes. |
| */ |
| public final class JdtUtil { |
| private static final String JSO_CLASS = "com/google/gwt/core/client/JavaScriptObject"; |
| |
| /** |
| * Returns a source name from an array of names. |
| */ |
| public static String asDottedString(char[][] name) { |
| return join(name, "."); |
| } |
| |
| /** |
| * Returns a string name from an array of names using {@code separator}. |
| */ |
| public static String join(char[][] name, String separator) { |
| StringBuilder result = new StringBuilder(); |
| if (name.length > 0) { |
| result.append(name[0]); |
| } |
| |
| for (int i = 1; i < name.length; ++i) { |
| result.append(separator); |
| result.append(name[i]); |
| } |
| return result.toString(); |
| } |
| |
| /** |
| * Returns the name of the class from reference binding. |
| * <p> |
| * JDT Core (at least 3.11.0.v20150407) returns <code>$Local$</code> synthetic name for local |
| * classes.<br> |
| * This method aware about local classes and instead of <code>$Local$</code> synthetic name |
| * returns fully qualified name of the local class in form of anonymous class (e.g. |
| * <code>test.Class1$2</code>). |
| * </p> |
| */ |
| public static String getClassName(ReferenceBinding binding) { |
| if (binding instanceof LocalTypeBinding) { |
| // Using here constantPoolName() instead of coumpoundName due JDT not computing the |
| // right compoundName for lambdas inside local class. |
| return InternalName.toBinaryName(String.valueOf(binding.constantPoolName())); |
| } |
| |
| return asDottedString(binding.compoundName); |
| } |
| |
| /** |
| * Returns the top type of the compilation unit that defines |
| * {@code binding}. |
| */ |
| public static String getDefiningCompilationUnitType(ReferenceBinding binding) { |
| // Get the compilation unit type name. |
| // TODO(rluble): check that this is valid for classes declared in the same compilation unit |
| // top scope. |
| return asDottedString(binding.outermostEnclosingType().compoundName); |
| } |
| |
| public static String getSourceName(TypeBinding classBinding) { |
| return getSourceName(CharOperation.charToString(classBinding.qualifiedPackageName()), |
| CharOperation.charToString(classBinding.qualifiedSourceName())); |
| } |
| |
| public static String getSourceName(String qualifiedPackageName, String qualifiedSourceName) { |
| return Joiner.on(".").skipNulls().join(new String[] { |
| Strings.emptyToNull(qualifiedPackageName), |
| qualifiedSourceName}); |
| } |
| |
| public static String getBinaryName(TypeBinding classBinding) { |
| return getBinaryName(CharOperation.charToString(classBinding.qualifiedPackageName()), |
| CharOperation.charToString(classBinding.qualifiedSourceName())); |
| } |
| |
| public static String getBinaryName(String qualifiedPackageName, String qualifiedSourceName) { |
| return Joiner.on(".").skipNulls().join(new String[] { |
| Strings.emptyToNull(qualifiedPackageName), |
| qualifiedSourceName.replace('.','$')}); |
| } |
| |
| public static boolean isInnerClass(ReferenceBinding binding) { |
| return binding.isNestedType() && !binding.isStatic(); |
| } |
| |
| /** |
| * Get a readable method description from {@code methodBinding} conforming with JSNI formatting. |
| * <p> |
| * See examples: |
| * <ul> |
| * <li>a constructor of class A with a java.lang.String parameter will be formatted as |
| * "new(Ljava/lang/String;).</li> |
| * <li>a method with name m with an parameter of class java.lang.Object and return type boolean |
| * will be formatted as "m(Ljava/lang/Object;</li> |
| * </ul>, |
| */ |
| public static String formatMethodSignature(MethodBinding methodBinding) { |
| ReferenceBinding declaringClassBinding = methodBinding.declaringClass; |
| StringBuilder methodNameWithSignature = new StringBuilder(); |
| String methodName = String.valueOf(methodBinding.selector); |
| List<TypeBinding> parameterTypeBindings = Lists.newArrayList(); |
| if (methodName.equals("<init>")) { |
| // It is a constructor. |
| // (1) use the JSNI methodName instead of <init>. |
| methodName = "new"; |
| // (2) add the implicit constructor parameters types for non static inner classes. |
| if (isInnerClass(declaringClassBinding)) { |
| NestedTypeBinding nestedBinding = (NestedTypeBinding) declaringClassBinding; |
| if (nestedBinding.enclosingInstances != null) { |
| for (SyntheticArgumentBinding argumentBinding : nestedBinding.enclosingInstances) { |
| parameterTypeBindings.add(argumentBinding.type); |
| } |
| } |
| } |
| } |
| |
| parameterTypeBindings.addAll(Arrays.asList(methodBinding.parameters)); |
| methodNameWithSignature.append(methodName); |
| methodNameWithSignature.append("("); |
| for (TypeBinding parameterTypeBinding : parameterTypeBindings) { |
| methodNameWithSignature.append(parameterTypeBinding.signature()); |
| } |
| methodNameWithSignature.append(")"); |
| return methodNameWithSignature.toString(); |
| } |
| |
| public static String formatBinding(MethodBinding methodBinding) { |
| String accessModifier = null; |
| if (methodBinding.isProtected()) { |
| accessModifier = "protected"; |
| } else if (methodBinding.isPrivate()) { |
| accessModifier = "private"; |
| } else if (methodBinding.isPublic()) { |
| accessModifier = "public"; |
| } |
| return Joiner.on(" ").skipNulls().join( |
| accessModifier, |
| methodBinding.isStatic() ? "static" : null, |
| getSourceName(methodBinding.declaringClass) + "." + |
| formatMethodSignature(methodBinding) |
| ); |
| } |
| |
| private JdtUtil() { |
| } |
| |
| public static String getAnnotationParameterString( |
| AnnotationBinding annotationBinding, String parameterName) { |
| if (annotationBinding != null) { |
| for (ElementValuePair parameterNameValuePair : annotationBinding.getElementValuePairs()) { |
| if (parameterNameValuePair.getValue() instanceof StringConstant && |
| parameterName.equals(String.valueOf(parameterNameValuePair.getName()))) { |
| return ((StringConstant) parameterNameValuePair.getValue()).stringValue(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static boolean getAnnotationParameterBoolean( |
| AnnotationBinding annotationBinding, String parameterName, boolean defaultValue) { |
| Boolean booleanParameterValue = getAnnotationParameterBoolean(annotationBinding, parameterName); |
| return booleanParameterValue == null ? defaultValue : booleanParameterValue; |
| } |
| |
| public static Boolean getAnnotationParameterBoolean( |
| AnnotationBinding annotationBinding, String parameterName) { |
| if (annotationBinding != null) { |
| for (ElementValuePair parameterNameValuePair : annotationBinding.getElementValuePairs()) { |
| if (parameterNameValuePair.getValue() instanceof BooleanConstant && |
| parameterName.equals(String.valueOf(parameterNameValuePair.getName()))) { |
| return ((BooleanConstant) parameterNameValuePair.getValue()).booleanValue(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static AnnotationBinding getAnnotationByName(Annotation[] annotations, String name) { |
| if (annotations == null) { |
| return null; |
| } |
| for (Annotation annotation : annotations) { |
| AnnotationBinding annotationBinding = annotation.getCompilerAnnotation(); |
| if (matchAnnotationName(annotationBinding, name)) { |
| return annotationBinding; |
| } |
| } |
| return null; |
| } |
| |
| public static AnnotationBinding getAnnotationByName( |
| AnnotationBinding[] annotationsBindings, String name) { |
| if (annotationsBindings == null) { |
| return null; |
| } |
| for (AnnotationBinding annotationBinding : annotationsBindings) { |
| if (matchAnnotationName(annotationBinding, name)) { |
| return annotationBinding; |
| } |
| } |
| return null; |
| } |
| |
| private static boolean matchAnnotationName(AnnotationBinding annotationBinding, String name) { |
| if (annotationBinding == null) { |
| return false; |
| } |
| return name.equals(CharOperation.toString(annotationBinding.getAnnotationType().compoundName)); |
| } |
| |
| public static TypeBinding getAnnotationParameterTypeBinding( |
| AnnotationBinding annotationBinding, String parameterName) { |
| if (annotationBinding != null) { |
| for (ElementValuePair parameterNameValuePair : annotationBinding.getElementValuePairs()) { |
| if (parameterNameValuePair.getValue() instanceof Class && |
| parameterName.equals(String.valueOf(parameterNameValuePair.getName()))) { |
| return (TypeBinding) parameterNameValuePair.getValue(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static TypeBinding[] getAnnotationParameterTypeBindingArray( |
| AnnotationBinding annotationBinding, String parameterName) { |
| if (annotationBinding == null) { |
| return null; |
| } |
| |
| for (ElementValuePair parameterNameValuePair : annotationBinding.getElementValuePairs()) { |
| Object value = parameterNameValuePair.getValue(); |
| if (!parameterName.equals(String.valueOf(parameterNameValuePair.getName()))) { |
| continue; |
| } |
| if (value instanceof Object[]) { |
| Object[] values = (Object[]) value; |
| TypeBinding bindings[] = new TypeBinding[values.length]; |
| System.arraycopy(values, 0, bindings, 0, values.length); |
| return bindings; |
| } |
| assert value instanceof TypeBinding; |
| return new TypeBinding[] {(TypeBinding) value}; |
| } |
| return null; |
| } |
| |
| public static StringConstant[] getAnnotationParameterStringConstantArray( |
| AnnotationBinding annotationBinding, String parameterName) { |
| if (annotationBinding == null) { |
| return null; |
| } |
| for (ElementValuePair parameterNameValuePair : annotationBinding.getElementValuePairs()) { |
| if (!parameterName.equals(String.valueOf(parameterNameValuePair.getName()))) { |
| continue; |
| } |
| Object value = parameterNameValuePair.getValue(); |
| if (value instanceof Object[]) { |
| Object[] values = (Object[]) value; |
| StringConstant[] stringConstants = new StringConstant[values.length]; |
| System.arraycopy(values, 0, stringConstants, 0, values.length); |
| return stringConstants; |
| } |
| assert value instanceof StringConstant; |
| return new StringConstant[] {(StringConstant) value}; |
| } |
| return null; |
| } |
| |
| public static Set<String> getSuppressedWarnings(Annotation[] annotations) { |
| if (annotations == null) { |
| return ImmutableSet.of(); |
| } |
| AnnotationBinding suppressWarnings = |
| getAnnotationByName(annotations, SuppressWarnings.class.getName()); |
| if (suppressWarnings != null) { |
| StringConstant[] values = |
| JdtUtil.getAnnotationParameterStringConstantArray(suppressWarnings, "value"); |
| return FluentIterable.from(Arrays.asList(values)) |
| .transform(new Function<StringConstant, String>() { |
| @Override |
| public String apply(StringConstant value) { |
| return value.stringValue(); |
| } |
| }) |
| .toSet(); |
| } |
| return ImmutableSet.of(); |
| } |
| |
| public static String signature(FieldBinding binding) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(binding.declaringClass.constantPoolName()); |
| sb.append('.'); |
| sb.append(binding.name); |
| sb.append(':'); |
| sb.append(binding.type.signature()); |
| return sb.toString(); |
| } |
| |
| public static String signature(MethodBinding binding) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(binding.declaringClass.constantPoolName()); |
| sb.append('.'); |
| sb.append(binding.selector); |
| sb.append('('); |
| for (TypeBinding paramType : binding.parameters) { |
| sb.append(paramType.signature()); |
| } |
| sb.append(')'); |
| sb.append(binding.returnType.signature()); |
| return sb.toString(); |
| } |
| |
| public static String signature(TypeBinding binding) { |
| assert !binding.isIntersectionType18() && !binding.isIntersectionType(); |
| if (binding.isBaseType()) { |
| return String.valueOf(binding.sourceName()); |
| } else { |
| return String.valueOf(binding.constantPoolName()); |
| } |
| } |
| |
| public static void setClassDispositionFromBinding(SourceTypeBinding binding, JDeclaredType type) { |
| if (binding.isNestedType()) { |
| if (isLocalClass(binding)) { |
| type.setClassDisposition(JDeclaredType.NestedClassDisposition.LOCAL); |
| } else if (binding.isAnonymousType()) { |
| type.setClassDisposition(JDeclaredType.NestedClassDisposition.ANONYMOUS); |
| } else if (isInnerClass(binding)) { |
| type.setClassDisposition(JDeclaredType.NestedClassDisposition.INNER); |
| } else if (isStaticClass(binding)) { |
| type.setClassDisposition(JDeclaredType.NestedClassDisposition.STATIC); |
| } |
| } else { |
| type.setClassDisposition(JDeclaredType.NestedClassDisposition.TOP_LEVEL); |
| } |
| } |
| |
| public static boolean isLocalClass(SourceTypeBinding binding) { |
| return binding.isLocalType() && !binding.isAnonymousType(); |
| } |
| |
| public static boolean isStaticClass(SourceTypeBinding binding) { |
| return binding.isNestedType() && binding.isStatic(); |
| } |
| |
| /** |
| * Returns {@code true} if {@code typeBinding} is {@code JavaScriptObject} or |
| * any subtype. |
| */ |
| public static boolean isJso(TypeBinding typeBinding) { |
| if (!(typeBinding instanceof ReferenceBinding)) { |
| return false; |
| } |
| ReferenceBinding binding = (ReferenceBinding) typeBinding; |
| while (binding != null) { |
| if (JSO_CLASS.equals(String.valueOf(binding.constantPoolName()))) { |
| return true; |
| } |
| binding = binding.superclass(); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns {@code true} if {@code typeBinding} is a subtype of |
| * {@code JavaScriptObject}, but not {@code JavaScriptObject} itself. |
| */ |
| public static boolean isJsoSubclass(TypeBinding typeBinding) { |
| if (!(typeBinding instanceof ReferenceBinding)) { |
| return false; |
| } |
| ReferenceBinding binding = (ReferenceBinding) typeBinding; |
| return isJso(binding.superclass()); |
| } |
| |
| public static Iterable<ReferenceBinding> getSuperInterfacesRequiringInitialization( |
| ReferenceBinding type) { |
| Iterable<ReferenceBinding> interfaces = Collections.emptyList(); |
| for (ReferenceBinding interfaceType : type.superInterfaces()) { |
| interfaces = |
| Iterables.concat(interfaces, getSuperInterfacesRequiringInitialization(interfaceType)); |
| if (hasDefaultMethods(interfaceType)) { |
| interfaces = Iterables.concat(interfaces, Collections.singleton(interfaceType)); |
| } |
| } |
| return interfaces; |
| } |
| |
| private static boolean hasDefaultMethods(ReferenceBinding interfaceType) { |
| return Iterables.any(Arrays.asList(interfaceType.methods()), new Predicate<MethodBinding>() { |
| @Override |
| public boolean apply(MethodBinding methodBinding) { |
| return methodBinding.isDefaultMethod(); |
| } |
| }); |
| } |
| |
| /* |
| * Implicit conversion helpers. |
| */ |
| |
| public static boolean requiresBoxing(int implicitConversion) { |
| return implicitConversion != -1 |
| && (implicitConversion & TypeIds.BOXING) != 0; |
| } |
| |
| public static boolean requiresUnboxing(int implicitConversion) { |
| return implicitConversion != -1 |
| && (implicitConversion & TypeIds.UNBOXING) != 0; |
| } |
| |
| public static BaseTypeBinding getBoxingPrimitiveType(ClassScope scope, int implicitConversion) { |
| int typeId = (implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4; |
| return getBaseTypeBinding(scope, typeId); |
| } |
| |
| public static BaseTypeBinding getUnboxingPrimitiveType( |
| ClassScope scope, int implicitConversion) { |
| if (needsCastBeforeUnbox(scope, implicitConversion)) { |
| int typeId = (implicitConversion & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4; |
| return getBaseTypeBinding(scope, typeId); |
| } |
| int compileTypeId = implicitConversion & TypeIds.COMPILE_TYPE_MASK; |
| return getBaseTypeBinding(scope, compileTypeId); |
| } |
| |
| public static BaseTypeBinding getBaseTypeBinding(ClassScope scope, int typeId) { |
| return (BaseTypeBinding) TypeBinding.wellKnownType(scope, typeId); |
| } |
| |
| public static ReferenceBinding getBoxedTypeBinding( |
| ClassScope scope, BaseTypeBinding primitiveType) { |
| return (ReferenceBinding) scope.boxing(primitiveType); |
| } |
| |
| public static boolean needsCastBeforeUnbox(ClassScope scope, int implicitConversion) { |
| // values of specific types like j.l.Object need casting before auto unboxing. |
| int compileTypeId = implicitConversion & TypeIds.COMPILE_TYPE_MASK; |
| return !(TypeBinding.wellKnownType(scope, compileTypeId) instanceof BaseTypeBinding); |
| } |
| |
| private static final String VALUE_SUFFIX = "Value"; |
| private static final String VALUE_OF_METHOD_NAME = "valueOf"; |
| |
| private static final char[] VALUE_SUFFIX_ = VALUE_SUFFIX.toCharArray(); |
| private static final char[] VALUE_OF_ = VALUE_OF_METHOD_NAME.toCharArray(); |
| |
| public static MethodBinding getBoxingMethodBinding( |
| ClassScope scope, BaseTypeBinding primitiveType) { |
| ReferenceBinding boxType = (ReferenceBinding) scope.boxing(primitiveType); |
| MethodBinding valueOfMethod = boxType.getExactMethod(VALUE_OF_, |
| new TypeBinding[]{primitiveType}, scope.compilationUnitScope()); |
| assert valueOfMethod != null; |
| return valueOfMethod; |
| } |
| |
| public static MethodBinding getUnboxingMethodBinding( |
| ClassScope scope, BaseTypeBinding primitiveType) { |
| ReferenceBinding boxType = (ReferenceBinding) scope.boxing(primitiveType); |
| char[] selector = CharOperation.concat(primitiveType.simpleName, VALUE_SUFFIX_); |
| |
| MethodBinding valueMethod = |
| boxType.getExactMethod(selector, new TypeBinding[0], scope.compilationUnitScope()); |
| assert valueMethod != null; |
| return valueMethod; |
| } |
| } |