|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
other via boolean "and" on each bit.
Element.
Tree.
AnnotatedTypeMirror.ProcessingEnvironment
instance and syntax tree root.
AnnotatedTypeMirror.AnnotatedTypeUtils
Tree.
Element.
AnnotationMirror based on their fully
qualified name.
Throwable if any of its
parameters is a null.Field may be re-assigned regardless of the
immutability of the enclosing class or object instance.ReadOnly
instance.this object.t whose erasure type
is superType.
SourceChecker that provides a simple SourceVisitor implementation for typical assignment and
pseudo-assignment checking of annotated types.SourceVisitor that performs assignment and pseudo-assignment
checking, method invocation checking, and assignability checking.AnnotatedTypeFactory to optionally use
flow-sensitive qualifier inference, qualifier polymorphism, implicit annotations
via ImplicitFor, and user-specified defaults via DefaultQualifierGraphQualifierHierarchy that
represents the hierarchy built so far
SourceChecker to invoke on the input source tree.
checkers.igj.quals
qualifiers that finds (and verifies the absence of) immutability errors.Interned
qualifier that finds (and verifies the absence of) equality-testing and
interning errors.NonNull
qualifier that finds (and verifies the absence of) null pointer errors.Collection.toArray() and determines
the appropriate nullness type of the returned value.new.
AnnotatedTypeMirror.AnnotatedExecutableType of a constructor
invocation.
GenKillBits that is a deep copy of the
GenKillBits passed as an argument.
AnnotationMirror as keys.
Set suitable for storing AnnotationMirrors.
Flow instance that performs flow sensitive analysis
to infer qualifiers on unqualified types.
SourceVisitor that the checker should use to scan
input source trees.
TypeQualifiers, return an immutable set with the same set
of classes as the annotation.
TreeAnnotator that adds annotations to a type based
on the contents of a tree.
TypeAnnotator that adds annotations to a type based
on the content of the type itself.
@QReadOnly behavior on generic types,
creating a new TypeHierarchy class that allows a
comparison of type arguments to succeed if the left hand side
is annotated with @QReadOnly or if the regular
comparison succeeds.
DefaultQualifier annotation applies.Elements.
Elements helper to use when scanning.
Elements.
Elements{@link TreePath}.
{@link TreePath}.
TreePath.
DefaultQualifier annotations.
DefaultQualifier annotations.
AnnotationMirror given by a particular annotation
class.
AnnotationMirror given by a particular
fully-qualified name.
AnnotationMirror given by a particular
fully-qualified name.
GenKillBits with the specified set of keys.
GenKillBits that is a deep copy of the
GenKillBits passed as an argument.
AnnotatedTypeFactory.fromElement(Element).
A in the type
A.B.
IllegalArgumentException if the passed type is not iterable.
kind of this type
Tree under the current root by
checking from the visitor's current path, and only using
Trees.getPath(CompilationUnitTree, Tree) (which is much slower)
only if node is not found on the current path.
Element
this, for the scope of this tree.
this in the current location, which can
be used if this has a special semantics (e.g.
TypeMirror for usage of Element as a value.
GraphQualifierHierarchy.BaseTypeVisitor implementation.I annotation value key
AnnotatedTypeFactory that accounts for the properties of the
Interned type system.InterningAnnotatedTypeFactory that operates on a
particular AST.
Interned qualifier that
finds (and verifies the absence of) equality-testing and interning errors.Interned type
qualifier that uses the BaseTypeVisitor implementation.Interned.
TreePath is an anonymous constructor (the constructor for an
anonymous class.
JavariAnnotatedTypeFactory that operates on a
particular AST.
\@ReadOnly, \@Mutable, \@Assignable, \@PolyRead and \@QReadOnly).@ReadOnly, @Mutable and @Assignable) that
extends BaseTypeVisitor.Tree.Location from a position and Tree.Kind.
@I in the type of the method type base on the method
invocation tree parameters.
ReadOnly.NonNull annotation to a type that is:
null literal)
DefaultQualifier annotation and
matches its location criteria
NonNull by flow-sensitive inference
Raw annotation to
NullnessAnnotatedTypeFactory.
NonNull.
other via boolean "or" on each bit.
ExecutableElements)
ExecutableElements).
@I in the elementType based
on owner, according to is specification.
@ThisMutable
implicit annotations with the qualified supertype annotation,
if the owner doesn't have a @ReadOnly annotation.
@I in the super types with the
immutability of the current type
ReadOnly and Mutable: only Mutable can be assigned
to it, and it can only be assigned to ReadOnly.QualifierPolymorphism instance that uses the given
checker for querying type qualifiers and the given factory for getting
annotated types.
this is Raw,
this.field might be null even if field was declared to be
NonNull.Mutable.SourceVisitor will scan.
PrintStream for printing debug messages, such as
System.out or System.err, or null if no debugging output
should be emitted.
checker.skipClasses property.
checker.skipClasses property.
AnnotatedTypeMirrors.SimpleAnnotatedTypeVisitor with
default value being null
SimpleAnnotatedTypeVisitor with
the default value being the passed defaultValue
SourceVisitor to use for scanning a source tree.
t, with all
instances of from type substituted with their correspondents
in to and return the substituted in type.
SuppressWarnings annotation.Element ("symbol") for the given Tree API node.
TypeAnnotator from the given checker, using that checker's
TypeQualifiers annotation to determine the annotations that are
in the type hierarchy.
SourceVisitor.
Trees instance to use for scanning.
Trees instance to use for tree node path finding.
Tree.TypeAnnotator from the given checker, using that checker's
TypeQualifiers annotation to determine the annotations that are
in the type hierarchy.
AnnotatedTypeMirror subtype relationships.TypeHierarchy for the type system
whose qualifiers represented in qualifierHierarchy.
TypeElement.Checker.Types helper to use when scanning.
TypeMirrors.
Elements.SubtypeOf.value(),
in the type qualifiers declarations.v.visit(t, null).
BaseTypeVisitor.commonAssignmentCheck(Tree, ExpressionTree, String, Object).
@PolyRead outside a
@PolyRead context.
BaseTypeVisitor.checkAssignability(AnnotatedTypeMirror, Tree).
.iterator call
null type.
null type.
BaseTypeVisitor.checkAssignability(AnnotatedTypeMirror, Tree).
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||