| package org.checkerframework.checker.signature; |
| |
| import com.sun.source.tree.BinaryTree; |
| import com.sun.source.tree.CompoundAssignmentTree; |
| import com.sun.source.tree.ExpressionTree; |
| import com.sun.source.tree.LiteralTree; |
| import com.sun.source.tree.MemberSelectTree; |
| import com.sun.source.tree.MethodInvocationTree; |
| import com.sun.source.tree.PrimitiveTypeTree; |
| import com.sun.source.tree.Tree; |
| import java.lang.annotation.Annotation; |
| import java.util.Set; |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.element.Element; |
| import javax.lang.model.element.ElementKind; |
| import javax.lang.model.element.ExecutableElement; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.type.TypeKind; |
| import javax.lang.model.type.TypeMirror; |
| import org.checkerframework.checker.signature.qual.ArrayWithoutPackage; |
| import org.checkerframework.checker.signature.qual.BinaryName; |
| import org.checkerframework.checker.signature.qual.BinaryNameOrPrimitiveType; |
| import org.checkerframework.checker.signature.qual.BinaryNameWithoutPackage; |
| import org.checkerframework.checker.signature.qual.CanonicalName; |
| import org.checkerframework.checker.signature.qual.CanonicalNameAndBinaryName; |
| import org.checkerframework.checker.signature.qual.ClassGetName; |
| import org.checkerframework.checker.signature.qual.ClassGetSimpleName; |
| import org.checkerframework.checker.signature.qual.DotSeparatedIdentifiers; |
| import org.checkerframework.checker.signature.qual.DotSeparatedIdentifiersOrPrimitiveType; |
| import org.checkerframework.checker.signature.qual.FieldDescriptor; |
| import org.checkerframework.checker.signature.qual.FieldDescriptorForPrimitive; |
| import org.checkerframework.checker.signature.qual.FieldDescriptorWithoutPackage; |
| import org.checkerframework.checker.signature.qual.FqBinaryName; |
| import org.checkerframework.checker.signature.qual.FullyQualifiedName; |
| import org.checkerframework.checker.signature.qual.Identifier; |
| import org.checkerframework.checker.signature.qual.IdentifierOrPrimitiveType; |
| import org.checkerframework.checker.signature.qual.InternalForm; |
| import org.checkerframework.checker.signature.qual.PrimitiveType; |
| import org.checkerframework.checker.signature.qual.SignatureBottom; |
| import org.checkerframework.checker.signature.qual.SignatureUnknown; |
| import org.checkerframework.common.basetype.BaseAnnotatedTypeFactory; |
| import org.checkerframework.common.basetype.BaseTypeChecker; |
| import org.checkerframework.framework.type.AnnotatedTypeFactory; |
| import org.checkerframework.framework.type.AnnotatedTypeMirror; |
| import org.checkerframework.framework.type.treeannotator.ListTreeAnnotator; |
| import org.checkerframework.framework.type.treeannotator.LiteralTreeAnnotator; |
| import org.checkerframework.framework.type.treeannotator.TreeAnnotator; |
| import org.checkerframework.javacutil.AnnotationBuilder; |
| import org.checkerframework.javacutil.TreeUtils; |
| import org.checkerframework.javacutil.TypesUtils; |
| import org.plumelib.reflection.SignatureRegexes; |
| |
| // TODO: Does not yet handle method signature annotations, such as |
| // @MethodDescriptor. |
| |
| /** Accounts for the effects of certain calls to String.replace. */ |
| public class SignatureAnnotatedTypeFactory extends BaseAnnotatedTypeFactory { |
| |
| /** The {@literal @}{@link SignatureUnknown} annotation. */ |
| protected final AnnotationMirror SIGNATURE_UNKNOWN = |
| AnnotationBuilder.fromClass(elements, SignatureUnknown.class); |
| /** The {@literal @}{@link BinaryName} annotation. */ |
| protected final AnnotationMirror BINARY_NAME = |
| AnnotationBuilder.fromClass(elements, BinaryName.class); |
| /** The {@literal @}{@link InternalForm} annotation. */ |
| protected final AnnotationMirror INTERNAL_FORM = |
| AnnotationBuilder.fromClass(elements, InternalForm.class); |
| /** The {@literal @}{@link DotSeparatedIdentifiers} annotation. */ |
| protected final AnnotationMirror DOT_SEPARATED_IDENTIFIERS = |
| AnnotationBuilder.fromClass(elements, DotSeparatedIdentifiers.class); |
| /** The {@literal @}{@link CanonicalName} annotation. */ |
| protected final AnnotationMirror CANONICAL_NAME = |
| AnnotationBuilder.fromClass(elements, CanonicalName.class); |
| /** The {@literal @}{@link CanonicalNameAndBinaryName} annotation. */ |
| protected final AnnotationMirror CANONICAL_NAME_AND_BINARY_NAME = |
| AnnotationBuilder.fromClass(elements, CanonicalNameAndBinaryName.class); |
| /** The {@literal @}{@link PrimitiveType} annotation. */ |
| protected final AnnotationMirror PRIMITIVE_TYPE = |
| AnnotationBuilder.fromClass(elements, PrimitiveType.class); |
| |
| /** The {@link String#replace(char, char)} method. */ |
| private final ExecutableElement replaceCharChar = |
| TreeUtils.getMethod("java.lang.String", "replace", processingEnv, "char", "char"); |
| |
| /** The {@link String#replace(CharSequence, CharSequence)} method. */ |
| private final ExecutableElement replaceCharSequenceCharSequence = |
| TreeUtils.getMethod( |
| "java.lang.String", |
| "replace", |
| processingEnv, |
| "java.lang.CharSequence", |
| "java.lang.CharSequence"); |
| |
| /** The {@link Class#getName()} method. */ |
| private final ExecutableElement classGetName = |
| TreeUtils.getMethod("java.lang.Class", "getName", processingEnv); |
| |
| /** The {@link Class#getCanonicalName()} method. */ |
| private final ExecutableElement classGetCanonicalName = |
| TreeUtils.getMethod(java.lang.Class.class, "getCanonicalName", processingEnv); |
| |
| /** |
| * Creates a SignatureAnnotatedTypeFactory. |
| * |
| * @param checker the type-checker assocated with this type factory |
| */ |
| public SignatureAnnotatedTypeFactory(BaseTypeChecker checker) { |
| super(checker); |
| |
| this.postInit(); |
| } |
| |
| @Override |
| protected Set<Class<? extends Annotation>> createSupportedTypeQualifiers() { |
| return getBundledTypeQualifiers(SignatureUnknown.class, SignatureBottom.class); |
| } |
| |
| @Override |
| public TreeAnnotator createTreeAnnotator() { |
| // It is slightly inefficient that super also adds a LiteralTreeAnnotator, but it seems |
| // better than hard-coding the behavior of super here. |
| return new ListTreeAnnotator( |
| signatureLiteralTreeAnnotator(this), |
| new SignatureTreeAnnotator(this), |
| super.createTreeAnnotator()); |
| } |
| |
| /** |
| * Create a LiteralTreeAnnotator for the Signature Checker. |
| * |
| * @param atypeFactory the type factory |
| * @return a LiteralTreeAnnotator for the Signature Checker |
| */ |
| private LiteralTreeAnnotator signatureLiteralTreeAnnotator(AnnotatedTypeFactory atypeFactory) { |
| LiteralTreeAnnotator result = new LiteralTreeAnnotator(atypeFactory); |
| result.addStandardLiteralQualifiers(); |
| |
| // The below code achieves the same effect as writing a meta-annotation |
| // @QualifierForLiterals(stringPatterns = "...") |
| // on each type qualifier definition. Annotation elements cannot be computations (not even |
| // string concatenations of literal strings) and cannot be not references to compile-time |
| // constants such as effectively-final fields. So every `stringPatterns = "..."` would have |
| // to be a literal string, which would be verbose ard hard to maintain. |
| result.addStringPattern( |
| SignatureRegexes.ArrayWithoutPackageRegex, |
| AnnotationBuilder.fromClass(elements, ArrayWithoutPackage.class)); |
| result.addStringPattern( |
| SignatureRegexes.BinaryNameRegex, AnnotationBuilder.fromClass(elements, BinaryName.class)); |
| result.addStringPattern( |
| SignatureRegexes.BinaryNameOrPrimitiveTypeRegex, |
| AnnotationBuilder.fromClass(elements, BinaryNameOrPrimitiveType.class)); |
| result.addStringPattern( |
| SignatureRegexes.BinaryNameWithoutPackageRegex, |
| AnnotationBuilder.fromClass(elements, BinaryNameWithoutPackage.class)); |
| result.addStringPattern( |
| SignatureRegexes.ClassGetNameRegex, |
| AnnotationBuilder.fromClass(elements, ClassGetName.class)); |
| result.addStringPattern( |
| SignatureRegexes.ClassGetSimpleNameRegex, |
| AnnotationBuilder.fromClass(elements, ClassGetSimpleName.class)); |
| result.addStringPattern( |
| SignatureRegexes.DotSeparatedIdentifiersRegex, |
| AnnotationBuilder.fromClass(elements, DotSeparatedIdentifiers.class)); |
| result.addStringPattern( |
| SignatureRegexes.DotSeparatedIdentifiersOrPrimitiveTypeRegex, |
| AnnotationBuilder.fromClass(elements, DotSeparatedIdentifiersOrPrimitiveType.class)); |
| result.addStringPattern( |
| SignatureRegexes.FieldDescriptorRegex, |
| AnnotationBuilder.fromClass(elements, FieldDescriptor.class)); |
| result.addStringPattern( |
| SignatureRegexes.FieldDescriptorForPrimitiveRegex, |
| AnnotationBuilder.fromClass(elements, FieldDescriptorForPrimitive.class)); |
| result.addStringPattern( |
| SignatureRegexes.FieldDescriptorWithoutPackageRegex, |
| AnnotationBuilder.fromClass(elements, FieldDescriptorWithoutPackage.class)); |
| result.addStringPattern( |
| SignatureRegexes.FqBinaryNameRegex, |
| AnnotationBuilder.fromClass(elements, FqBinaryName.class)); |
| result.addStringPattern( |
| SignatureRegexes.FullyQualifiedNameRegex, |
| AnnotationBuilder.fromClass(elements, FullyQualifiedName.class)); |
| result.addStringPattern( |
| SignatureRegexes.IdentifierRegex, AnnotationBuilder.fromClass(elements, Identifier.class)); |
| result.addStringPattern( |
| SignatureRegexes.IdentifierOrPrimitiveTypeRegex, |
| AnnotationBuilder.fromClass(elements, IdentifierOrPrimitiveType.class)); |
| result.addStringPattern( |
| SignatureRegexes.InternalFormRegex, |
| AnnotationBuilder.fromClass(elements, InternalForm.class)); |
| result.addStringPattern( |
| SignatureRegexes.PrimitiveTypeRegex, |
| AnnotationBuilder.fromClass(elements, PrimitiveType.class)); |
| return result; |
| } |
| |
| private class SignatureTreeAnnotator extends TreeAnnotator { |
| |
| public SignatureTreeAnnotator(AnnotatedTypeFactory atypeFactory) { |
| super(atypeFactory); |
| } |
| |
| @Override |
| public Void visitBinary(BinaryTree tree, AnnotatedTypeMirror type) { |
| if (TreeUtils.isStringConcatenation(tree)) { |
| type.removeAnnotationInHierarchy(SIGNATURE_UNKNOWN); |
| // This could be made more precise. |
| type.addAnnotation(SignatureUnknown.class); |
| } |
| return null; // super.visitBinary(tree, type); |
| } |
| |
| @Override |
| public Void visitCompoundAssignment(CompoundAssignmentTree node, AnnotatedTypeMirror type) { |
| if (TreeUtils.isStringCompoundConcatenation(node)) { |
| type.removeAnnotationInHierarchy(SIGNATURE_UNKNOWN); |
| // This could be made more precise. |
| type.addAnnotation(SignatureUnknown.class); |
| } |
| return null; // super.visitCompoundAssignment(node, type); |
| } |
| |
| /** |
| * String.replace, when called with specific constant arguments, converts between internal form |
| * and binary name: |
| * |
| * <pre><code> |
| * {@literal @}InternalForm String internalForm = binaryName.replace('.', '/'); |
| * {@literal @}BinaryName String binaryName = internalForm.replace('/', '.'); |
| * </code></pre> |
| * |
| * Class.getName and Class.getCanonicalName(): Cwhen called on a primitive type ,the return a |
| * {@link PrimitiveType}. When called on a non-array, non-nested, non-primitive type, they |
| * return a {@link BinaryName}: |
| * |
| * <pre><code> |
| * {@literal @}BinaryName String binaryName = MyClass.class.getName(); |
| * </code></pre> |
| */ |
| @Override |
| public Void visitMethodInvocation(MethodInvocationTree tree, AnnotatedTypeMirror type) { |
| if (TreeUtils.isMethodInvocation(tree, replaceCharChar, processingEnv) |
| || TreeUtils.isMethodInvocation(tree, replaceCharSequenceCharSequence, processingEnv)) { |
| char oldChar = ' '; // initial dummy value |
| char newChar = ' '; // initial dummy value |
| if (TreeUtils.isMethodInvocation(tree, replaceCharChar, processingEnv)) { |
| ExpressionTree arg0 = tree.getArguments().get(0); |
| ExpressionTree arg1 = tree.getArguments().get(1); |
| if (arg0.getKind() == Tree.Kind.CHAR_LITERAL |
| && arg1.getKind() == Tree.Kind.CHAR_LITERAL) { |
| oldChar = (char) ((LiteralTree) arg0).getValue(); |
| newChar = (char) ((LiteralTree) arg1).getValue(); |
| } |
| } else { |
| ExpressionTree arg0 = tree.getArguments().get(0); |
| ExpressionTree arg1 = tree.getArguments().get(1); |
| if (arg0.getKind() == Tree.Kind.STRING_LITERAL |
| && arg1.getKind() == Tree.Kind.STRING_LITERAL) { |
| String const0 = (String) ((LiteralTree) arg0).getValue(); |
| String const1 = (String) ((LiteralTree) arg1).getValue(); |
| if (const0.length() == 1 && const1.length() == 1) { |
| oldChar = const0.charAt(0); |
| newChar = const1.charAt(0); |
| } |
| } |
| } |
| ExpressionTree receiver = TreeUtils.getReceiverTree(tree); |
| final AnnotatedTypeMirror receiverType = getAnnotatedType(receiver); |
| if ((oldChar == '.' && newChar == '/') |
| && receiverType.getAnnotation(BinaryName.class) != null) { |
| type.replaceAnnotation(INTERNAL_FORM); |
| } else if ((oldChar == '/' && newChar == '.') |
| && receiverType.getAnnotation(InternalForm.class) != null) { |
| type.replaceAnnotation(BINARY_NAME); |
| } |
| } else { |
| boolean isClassGetName = TreeUtils.isMethodInvocation(tree, classGetName, processingEnv); |
| boolean isClassGetCanonicalName = |
| TreeUtils.isMethodInvocation(tree, classGetCanonicalName, processingEnv); |
| if (isClassGetName || isClassGetCanonicalName) { |
| ExpressionTree receiver = TreeUtils.getReceiverTree(tree); |
| if (TreeUtils.isClassLiteral(receiver)) { |
| ExpressionTree classExpr = ((MemberSelectTree) receiver).getExpression(); |
| if (classExpr.getKind() == Tree.Kind.PRIMITIVE_TYPE) { |
| if (((PrimitiveTypeTree) classExpr).getPrimitiveTypeKind() == TypeKind.VOID) { |
| // do nothing |
| } else { |
| type.replaceAnnotation(PRIMITIVE_TYPE); |
| } |
| } else { |
| // Binary name if non-array, non-primitive, non-nested. |
| TypeMirror literalType = TreeUtils.typeOf(classExpr); |
| if (literalType.getKind() == TypeKind.DECLARED) { |
| TypeElement typeElt = TypesUtils.getTypeElement(literalType); |
| Element enclosing = typeElt.getEnclosingElement(); |
| if (enclosing == null || enclosing.getKind() == ElementKind.PACKAGE) { |
| type.replaceAnnotation( |
| isClassGetName ? DOT_SEPARATED_IDENTIFIERS : CANONICAL_NAME_AND_BINARY_NAME); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return super.visitMethodInvocation(tree, type); |
| } |
| } |
| } |
