checkers.regex

Class RegexVisitor

java.lang.Object

com.sun.source.util.TreeScanner<R,P>

com.sun.source.util.TreePathScanner<R,P>

checkers.source.SourceVisitor<@Nullable Void,@Nullable Void>

checkers.basetype.BaseTypeVisitor<RegexChecker>

checkers.regex.RegexVisitor

All Implemented Interfaces:

TreeVisitor<@Nullable Void,@Nullable Void>

public class RegexVisitor
extends BaseTypeVisitor<RegexChecker>

A type-checking visitor for the Regex type system. This visitor does the following:

1. Allows any String to be passed to Pattern.compile if the Pattern.LITERAL flag is passed.
2. Checks compound String concatenation to ensure correct usage of Regex Strings.
3. Checks calls to MatchResult.start, MatchResult.end and MatchResult.group to ensure that a valid group number is passed.

See Also:

RegexChecker

Nested Class Summary

Nested classes/interfaces inherited from class checkers.basetype.BaseTypeVisitor

BaseTypeVisitor.TypeValidator

Field Summary

Fields inherited from class checkers.basetype.BaseTypeVisitor

annoFactory, annoTypes, checker, options, typeValidator, visitorState

Fields inherited from class checkers.source.SourceVisitor

atypeFactory, elements, root, trees, types

Constructor Summary

Constructors

Constructor and Description
RegexVisitor(RegexChecker checker, @Nullable CompilationUnitTree root)

Method Summary

Methods

Modifier and Type	Method and Description
boolean	isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType, AnnotatedTypeMirror.AnnotatedDeclaredType useType) Tests that the qualifiers present on the useType are valid qualifiers, given the qualifiers on the declaration of the type, declarationType.
boolean	isValidUse(AnnotatedTypeMirror.AnnotatedPrimitiveType type) Tests that the qualifiers present on the primitive type are valid.
@Nullable Void	visitCompoundAssignment(CompoundAssignmentTree node, @Nullable Void p) Case 2: Check String compound concatenation for valid Regex use.
@Nullable Void	visitMethodInvocation(MethodInvocationTree node, @Nullable Void p) Case 1: Don't require a Regex annotation on the String argument to Pattern.compile if the Pattern.LITERAL flag is passed.

Methods inherited from class checkers.basetype.BaseTypeVisitor

checkAccess, checkArguments, checkArrayInitialization, checkAssignability, checkConstructorInvocation, checkDefaultConstructor, checkForAnnotatedJdk, checkMethodInvocability, checkOverride, checkTypeArguments, checkTypecastRedundancy, checkTypecastSafety, commonAssignmentCheck, commonAssignmentCheck, commonAssignmentCheck, createTypeValidator, enclosingMemberSelect, enclosingStatement, isAccessAllowed, isAssignable, isValidUse, isVectorCopyInto, scan, shouldSkipUses, typeCheckVectorCopyIntoArgument, validateTypeOf, visitAnnotation, visitArrayAccess, visitAssignment, visitClass, visitCompilationUnit, visitConditionalExpression, visitEnhancedForLoop, visitIdentifier, visitInstanceOf, visitMethod, visitNewArray, visitNewClass, visitParameterizedType, visitReturn, visitTypeCast, visitTypeParameter, visitUnary, visitVariable

Methods inherited from class com.sun.source.util.TreePathScanner

getCurrentPath, scan

Methods inherited from class com.sun.source.util.TreeScanner

reduce, scan, visitAnnotatedType, visitArrayType, visitAssert, visitBinary, visitBlock, visitBreak, visitCase, visitCatch, visitContinue, visitDoWhileLoop, visitEmptyStatement, visitErroneous, visitExpressionStatement, visitForLoop, visitIf, visitImport, visitLabeledStatement, visitLambdaExpression, visitLiteral, visitMemberReference, visitMemberSelect, visitModifiers, visitOther, visitParenthesized, visitPrimitiveType, visitSwitch, visitSynchronized, visitThrow, visitTry, visitUnionType, visitWhileLoop, visitWildcard

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RegexVisitor

public RegexVisitor(RegexChecker checker,
            @Nullable CompilationUnitTree root)

Method Detail

visitMethodInvocation

public @Nullable Void visitMethodInvocation(MethodInvocationTree node,
                                   @Nullable Void p)

Case 1: Don't require a Regex annotation on the String argument to Pattern.compile if the Pattern.LITERAL flag is passed.

Specified by:

visitMethodInvocation in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitMethodInvocation in class BaseTypeVisitor<RegexChecker>

visitCompoundAssignment

public @Nullable Void visitCompoundAssignment(CompoundAssignmentTree node,
                                     @Nullable Void p)

Case 2: Check String compound concatenation for valid Regex use.

Specified by:

visitCompoundAssignment in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitCompoundAssignment in class BaseTypeVisitor<RegexChecker>

isValidUse

public boolean isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType,
                 AnnotatedTypeMirror.AnnotatedDeclaredType useType)

Description copied from class: BaseTypeVisitor

Tests that the qualifiers present on the useType are valid qualifiers, given the qualifiers on the declaration of the type, declarationType.

The check is shallow, as it does not descend into generic or array types (i.e. only performing the validity check on the raw type or outermost array dimension). BaseTypeVisitor.validateTypeOf(Tree) would call this for each type argument or array dimension separately.

For instance, in the IGJ type system, a @Mutable is an invalid qualifier for String, as String is declared as @Immutable String.

In most cases, useType simply needs to be a subtype of declarationType, but there are exceptions. In IGJ, a variable may be declared @ReadOnly String, even though String is @Immutable String; ReadOnly is not a subtype of Immutable.

Overrides:

isValidUse in class BaseTypeVisitor<RegexChecker>

Parameters:

declarationType - the type of the class (TypeElement)

useType - the use of the class (instance type)

Returns:

if the useType is a valid use of elemType

isValidUse

public boolean isValidUse(AnnotatedTypeMirror.AnnotatedPrimitiveType type)

Description copied from class: BaseTypeVisitor

Tests that the qualifiers present on the primitive type are valid. The default implementation always returns true. Subclasses should override this method to limit what annotations are allowed on primitive types.

Overrides:

isValidUse in class BaseTypeVisitor<RegexChecker>