jif.types

## Class JifTypeSystem_c

- java.lang.Object
- - polyglot.types.TypeSystem_c
  - - polyglot.ext.param.types.ParamTypeSystem_c<ParamInstance,Param>
    - - jif.types.JifTypeSystem_c

- All Implemented Interfaces:
    JifTypeSystem, polyglot.ext.param.types.ParamTypeSystem<ParamInstance,Param>, polyglot.types.TypeSystem

      public class JifTypeSystem_c
      extends polyglot.ext.param.types.ParamTypeSystem_c<ParamInstance,Param>
      implements JifTypeSystem

  An implementation of the `JifTypeSystem` interface.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class polyglot.types.TypeSystem_c

      `polyglot.types.TypeSystem_c.MostSpecificComparator<T extends polyglot.types.ProcedureInstance>`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected polyglot.types.TypeSystem` | `jlts`
    `protected polyglot.types.PrimitiveType` | `LABEL_`
    `protected LabelTypeCheckUtil` | `ltcu`
    `protected polyglot.types.PrimitiveType` | `PRINCIPAL_`
    `protected polyglot.types.Type` | `PRINCIPAL_CLASS_`

    - ### Fields inherited from class polyglot.ext.param.types.ParamTypeSystem_c

      `substCache`

    - ### Fields inherited from class polyglot.types.TypeSystem_c

      `ABSTRACT_METHOD_FLAGS, ACCESS_FLAGS, BOOLEAN_, BYTE_, CHAR_, CLASS_, CONSTRUCTOR_FLAGS, DOUBLE_, extInfo, FIELD_FLAGS, flagsForName, FLOAT_, INITIALIZER_FLAGS, INT_, INTERFACE_FIELD_FLAGS, loadedResolver, LOCAL_CLASS_FLAGS, LOCAL_FLAGS, LONG_, MEMBER_CLASS_FLAGS, METHOD_FLAGS, NULL_, OBJECT_, SHORT_, STRING_, systemResolver, THROWABLE_, TOP_LEVEL_CLASS_FLAGS, unknownPackage, unknownQualifier, unknownType, VOID_`

    - ### Fields inherited from interface polyglot.types.TypeSystem

      `SERIALIZE_MEMBERS_WITH_CONTAINER`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `JifTypeSystem_c(polyglot.types.TypeSystem jlts)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.util.List<polyglot.types.ReferenceType>` | `abstractSuperInterfaces(polyglot.types.ReferenceType rt)` Exposes utility method of TypeSystem_c
    `java.lang.String` | `accessPathDescrip(AccessPath path, java.lang.String kind)`
    `protected AccessPathField` | `accessPathField(AccessPath path, polyglot.types.FieldInstance fi, java.lang.String fieldName, polyglot.util.Position pos)` Factory method for constructing AccessPathField objects.
    `boolean` | `actsFor(Principal p, Principal q)` Returns true iff p actsfor q in the empty environment.
    `<Actor extends ActsForParam,Granter extends ActsForParam> ActsForConstraint<Actor,Granter>` | `actsForConstraint(polyglot.util.Position pos, Actor actor, Granter granter, boolean isEquiv)` Construct an acts-for constraint.
    `protected ActsForConstraintToJavaExpr` | `actsForConstraintTranslator()`
    `ArgLabel` | `argLabel(polyglot.util.Position pos, polyglot.types.LocalInstance vi, polyglot.types.CodeInstance ci)`
    `ArgLabel` | `argLabel(polyglot.util.Position pos, ParamInstance pi)`
    `protected polyglot.types.ArrayType` | `arrayType(polyglot.util.Position pos, polyglot.types.Type type)`
    `AuthConstraint` | `authConstraint(polyglot.util.Position pos, java.util.List<Principal> principals)` Construct an authority constraint.
    `AutoEndorseConstraint` | `autoEndorseConstraint(polyglot.util.Position pos, Label endorseTo)` Construct an autoendorse constraint.
    `ConfPolicy` | `bottomConfPolicy(polyglot.util.Position pos)`
    `IntegPolicy` | `bottomIntegPolicy(polyglot.util.Position pos)`
    `Label` | `bottomLabel()`
    `Label` | `bottomLabel(polyglot.util.Position pos)`
    `BottomPrincipal` | `bottomPrincipal(polyglot.util.Position pos)`
    `CallerConstraint` | `callerConstraint(polyglot.util.Position pos, java.util.List<Principal> principals)` Construct a caller constraint.
    `Label` | `callSitePCLabel(JifProcedureInstance pi)`
    `boolean` | `canCoerceToString(polyglot.types.Type t, polyglot.types.Context c)` In general, type t can be coerced to a String if t is a String, a primitive, or it has a toString() method.
    `void` | `checkInstantiation(polyglot.util.Position pos, polyglot.ext.param.types.PClass<ParamInstance,Param> t, java.util.List<? extends Param> args)`
    `polyglot.types.reflect.ClassFileLazyClassInitializer` | `classFileLazyClassInitializer(polyglot.types.reflect.ClassFile clazz)`
    `ConfPolicy` | `confProjection(Label L)`
    `Principal` | `conjunctivePrincipal(polyglot.util.Position pos, java.util.Collection<Principal> ps)`
    `Principal` | `conjunctivePrincipal(polyglot.util.Position pos, Principal l, Principal r)`
    `PrincipalToJavaExpr` | `conjunctivePrincipalTranslator()`
    `ConstArrayType` | `constArrayOf(polyglot.util.Position pos, polyglot.types.Type type)`
    `ConstArrayType` | `constArrayOf(polyglot.util.Position pos, polyglot.types.Type type, boolean castableToNonConst)`
    `ConstArrayType` | `constArrayOf(polyglot.util.Position pos, polyglot.types.Type type, int dims)`
    `ConstArrayType` | `constArrayOf(polyglot.util.Position pos, polyglot.types.Type type, int dims, boolean castableToNonConst)`
    `ConstArrayType` | `constArrayOf(polyglot.util.Position pos, polyglot.types.Type type, int dims, boolean castableToNonConst, boolean recurseIntoBaseType)`
    `ConstArrayType` | `constArrayOf(polyglot.types.Type type)`
    `ConstArrayType` | `constArrayOf(polyglot.types.Type type, int dims)`
    `polyglot.types.ConstructorInstance` | `constructorInstance(polyglot.util.Position pos, polyglot.types.ClassType container, polyglot.types.Flags flags, java.util.List<? extends polyglot.types.Type> formalTypes, java.util.List<? extends polyglot.types.Type> excTypes)`
    `CovariantParamLabel` | `covariantLabel(polyglot.util.Position pos, ParamInstance pi)`
    `polyglot.types.ParsedClassType` | `createClassType(polyglot.types.LazyClassInitializer init, polyglot.frontend.Source fromSource)`
    `JifContext` | `createContext()`
    `protected LabelEnv` | `createEmptyLabelEnv()`
    `LabelEnv` | `createLabelEnv()`
    `Solver` | `createSolver(java.lang.String solverName)` Returns a new label constraint system solver.
    `polyglot.types.LazyClassInitializer` | `defaultClassInitializer()`
    `polyglot.types.ConstructorInstance` | `defaultConstructor(polyglot.util.Position pos, polyglot.types.ClassType container)`
    `java.util.List<java.lang.String>` | `defaultPackageImports()`
    `DefaultSignature` | `defaultSignature()`
    `boolean` | `descendsFrom(polyglot.types.Type child, polyglot.types.Type ancestor)`
    `polyglot.types.LazyClassInitializer` | `deserializedClassInitializer()`
    `Principal` | `disjunctivePrincipal(polyglot.util.Position pos, java.util.Collection<Principal> ps)`
    `Principal` | `disjunctivePrincipal(polyglot.util.Position pos, Principal l, Principal r)`
    `PrincipalToJavaExpr` | `disjunctivePrincipalTranslator()`
    `DynamicLabel` | `dynamicLabel(polyglot.util.Position pos, AccessPath path)`
    `protected LabelToJavaExpr` | `dynamicLabelTranslator()`
    `DynamicPrincipal` | `dynamicPrincipal(polyglot.util.Position pos, AccessPath path)`
    `protected PrincipalToJavaExpr` | `dynamicPrincipalTranslator()`
    `boolean` | `equals(polyglot.types.TypeObject t1, polyglot.types.TypeObject t2)`
    `boolean` | `equalsNoStrip(polyglot.types.TypeObject t1, polyglot.types.TypeObject t2)` Compares t1 to t2 without stripping off all the parameters and labels
    `boolean` | `equalsStrip(polyglot.types.TypeObject t1, polyglot.types.TypeObject t2)` Compares t1 to t2, stripping off all the parameters and labels
    `ExceptionPath` | `exceptionPath(polyglot.types.Type type)`
    `AccessPath` | `exprToAccessPath(polyglot.ast.Expr e, JifContext context)` Create an AccessPath for the expression `e` in context `context`.
    `AccessPath` | `exprToAccessPath(polyglot.ast.Expr e, polyglot.types.Type expectedType, JifContext context)` Create an AccessPath for the expression `e` with expected type `expectedType` in context `context`.
    `Label` | `exprToLabel(JifTypeSystem ts, polyglot.ast.Expr e, JifContext context)`
    `Principal` | `exprToPrincipal(JifTypeSystem ts, polyglot.ast.Expr e, JifContext context)`
    `ExternalPrincipal` | `externalPrincipal(polyglot.util.Position pos, java.lang.String name)`
    `polyglot.types.ClassType` | `fatalException()`
    `polyglot.types.FieldInstance` | `fieldInstance(polyglot.util.Position pos, polyglot.types.ReferenceType container, polyglot.types.Flags flags, polyglot.types.Type type, java.lang.String name)`
    `VarLabel` | `freshLabelVariable(polyglot.util.Position pos, java.lang.String s, java.lang.String description)`
    `VarPrincipal` | `freshPrincipalVariable(polyglot.util.Position pos, java.lang.String s, java.lang.String description)`
    `Path` | `gotoPath(polyglot.ast.Branch.Kind kind, java.lang.String target)`
    `boolean` | `hasSafeConstructors(polyglot.types.ClassType ct)` Check if the class has safe constructors, that is, if the constructors of the class definitely do not access a final field (possibly on a subclass) before that field has been initalized.
    `polyglot.types.ClassType` | `hasUntrustedAncestor(polyglot.types.Type t)` Check if the class has an untrusted non-jif ancestor.
    `void` | `initialize(polyglot.types.TopLevelResolver loadedResolver, polyglot.frontend.ExtensionInfo extInfo)` Initializes the type system and its internal constants.
    `polyglot.types.InitializerInstance` | `initializerInstance(polyglot.util.Position pos, polyglot.types.ClassType container, polyglot.types.Flags flags)`
    `IntegPolicy` | `integProjection(Label L)`
    `boolean` | `isAccessible(polyglot.types.MemberInstance mi, polyglot.types.ClassType contextClass)` Exposes utility method of TypeSystem_c
    `boolean` | `isCastValid(polyglot.types.Type fromType, polyglot.types.Type toType)`
    `boolean` | `isFinalAccessExpr(polyglot.ast.Expr e)`
    `boolean` | `isFinalAccessExprOrConst(polyglot.ast.Expr e)`
    `boolean` | `isFinalAccessExprOrConst(polyglot.ast.Expr e, polyglot.types.Type expectedType)`
    `boolean` | `isImplicitCastValid(polyglot.types.Type fromType, polyglot.types.Type toType)`
    `boolean` | `isLabel(polyglot.types.Type type)` Tests if the type is "label".
    `boolean` | `isLabeled(polyglot.types.Type type)` Returns true if the type is labeled.
    `boolean` | `isMarkerFieldName(java.lang.String s)` Is the string s a special marker field name?
    `boolean` | `isParamsRuntimeRep(polyglot.types.Type t)` Returns true if the type is a Jif class, or if it is a non-Jif class that represents parameters at runtime.
    `boolean` | `isPrincipal(polyglot.types.Type type)` Tests if the type is "principal".
    `boolean` | `isSignature(polyglot.types.Type type)` Returns true if the type is a Jif class (will return false if the type is just a jif signature for a java class).
    `boolean` | `isSubtype(polyglot.types.Type child, polyglot.types.Type ancestor)`
    `JifConstructorInstance` | `jifConstructorInstance(polyglot.util.Position pos, polyglot.types.ClassType container, polyglot.types.Flags flags, Label startLabel, boolean isDefaultStartLabel, Label returnLabel, boolean isDefaultReturnLabel, java.util.List<? extends polyglot.types.Type> formalTypes, java.util.List<Label> formalArgLabels, java.util.List<? extends polyglot.types.Type> excTypes, java.util.List<Assertion> constraints)`
    `JifMethodInstance` | `jifMethodInstance(polyglot.util.Position pos, polyglot.types.ReferenceType container, polyglot.types.Flags flags, polyglot.types.Type returnType, java.lang.String name, Label startLabel, boolean isDefaultStartLabel, java.util.List<? extends polyglot.types.Type> formalTypes, java.util.List<Label> formalArgLabels, Label endLabel, boolean isDefaultEndLabel, java.util.List<? extends polyglot.types.Type> excTypes, java.util.List<Assertion> constraints)`
    `ConfPolicy` | `join(ConfPolicy p1, ConfPolicy p2)`
    `IntegPolicy` | `join(IntegPolicy p1, IntegPolicy p2)`
    `Label` | `join(Label L1, Label L2)` Returns the join of L1 and L2.
    `ConfPolicy` | `joinConfPolicy(polyglot.util.Position pos, java.util.Set<ConfPolicy> components)`
    `IntegPolicy` | `joinIntegPolicy(polyglot.util.Position pos, java.util.Set<IntegPolicy> components)`
    `Label` | `joinLabel(polyglot.util.Position pos, java.util.Set<Label> components)`
    `LabelToJavaExpr` | `joinLabelTranslator()`
    `polyglot.types.PrimitiveType` | `Label()` Returns the "label" type.
    `java.lang.String` | `LabelClassName()` Returns the name of the "label" type.
    `LabeledType` | `labeledType(polyglot.util.Position pos, polyglot.types.Type type, Label label)` Jif specific stuff
    `LabelLeAssertion` | `labelLeAssertion(polyglot.util.Position pos, Label lhs, Label rhs)` Construct an acts-for constraint.
    `protected LabelLeAssertionToJavaExpr` | `labelLeAssertionTranslator()`
    `Label` | `labelOfField(polyglot.types.FieldInstance vi, Label pc)` Get the label of the field, folding in the PC if appropriate.
    `Label` | `labelOfLocal(polyglot.types.LocalInstance vi, Label pc)` Get the label of the local, folding in the PC if appropriate.
    `Label` | `labelOfType(polyglot.types.Type type)` Get the label of the type, or bottom if unlabeled
    `Label` | `labelOfType(polyglot.types.Type type, Label defaultLabel)` Get the label of the type, or `defaultLabel` if unlabeled.
    `LabelTypeCheckUtil` | `labelTypeCheckUtil()`
    `java.lang.String` | `LabelUtilClassName()` Returns the name of the LabelUtil class.
    `polyglot.types.Type` | `leastCommonAncestor(polyglot.types.Type type1, polyglot.types.Type type2)` Override the superclass implementation, to handle label and principal parameters, and array base types correctly.
    `protected polyglot.types.Type` | `leastCommonAncestorSubtype(polyglot.types.Type subtype, polyglot.types.Type supertype)` Find out if the least common ancestor of subtype and supertype is supertype, given that strip(subtype) is a sub type of strip(supertype).
    `boolean` | `leq(Label L1, Label L2)` Returns true iff L1 <= L2 in the empty environment.
    `boolean` | `leq(Policy p1, Policy p2)`
    `polyglot.types.LocalInstance` | `localInstance(polyglot.util.Position pos, polyglot.types.Flags flags, polyglot.types.Type type, java.lang.String name)`
    `ConfPolicy` | `meet(ConfPolicy p1, ConfPolicy p2)`
    `IntegPolicy` | `meet(IntegPolicy p1, IntegPolicy p2)`
    `Label` | `meet(Label L1, Label L2)` Returns the meet of L1 and L2.
    `ConfPolicy` | `meetConfPolicy(polyglot.util.Position pos, java.util.Set<ConfPolicy> components)`
    `IntegPolicy` | `meetIntegPolicy(polyglot.util.Position pos, java.util.Set<IntegPolicy> components)`
    `Label` | `meetLabel(polyglot.util.Position pos, java.util.Set<Label> components)`
    `LabelToJavaExpr` | `meetLabelTranslator()`
    `polyglot.types.MethodInstance` | `methodInstance(polyglot.util.Position pos, polyglot.types.ReferenceType container, polyglot.types.Flags flags, polyglot.types.Type returnType, java.lang.String name, java.util.List<? extends polyglot.types.Type> formalTypes, java.util.List<? extends polyglot.types.Type> excTypes)`
    `polyglot.ext.param.types.MuPClass<ParamInstance,Param>` | `mutablePClass(polyglot.util.Position pos)`
    `boolean` | `needsDynamicTypeMethods(polyglot.types.Type ct)` Returns true if the class has runtime methods for cast and instanceof
    `boolean` | `needsImplClass(polyglot.types.Type jpt)` Returns true if the class has runtime methods for cast and instanceof
    `Label` | `noComponentsLabel()`
    `Label` | `noComponentsLabel(polyglot.util.Position pos)`
    `Label` | `notTaken()`
    `Label` | `notTaken(polyglot.util.Position pos)`
    `polyglot.types.ClassType` | `nullInstantiate(polyglot.util.Position pos, polyglot.ext.param.types.PClass<ParamInstance,Param> pc)`
    `boolean` | `numericConversionValid(polyglot.types.Type t, java.lang.Object value)`
    `PairLabel` | `pairLabel(polyglot.util.Position pos, ConfPolicy confPol, IntegPolicy integPol)`
    `protected LabelToJavaExpr` | `pairLabelTranslator()`
    `ParamInstance` | `paramInstance(polyglot.util.Position pos, JifClassType container, ParamInstance.Kind kind, java.lang.String name)` Constructs a parameter instance for a class parameter declaration
    `ParamLabel` | `paramLabel(polyglot.util.Position pos, ParamInstance pi)`
    `LabelToJavaExpr` | `paramLabelTranslator()`
    `PrincipalToJavaExpr` | `paramPrincipalTranslator()`
    `PathMap` | `pathMap()`
    `PathMap` | `pathMap(Path path, Label L)`
    `Label` | `pathToLabel(polyglot.util.Position pos, AccessPath path)`
    `Principal` | `pathToPrincipal(polyglot.util.Position pos, AccessPath path)`
    `polyglot.types.PrimitiveType` | `primitiveForName(java.lang.String name)`
    `polyglot.types.PrimitiveType` | `Principal()` Returns the "principal" type.
    `polyglot.types.Type` | `PrincipalClass()` Returns the class jif.lang.Principal.
    `java.lang.String` | `PrincipalClassName()` Returns the name of the "principal" type.
    `PrincipalInstance` | `principalInstance(polyglot.util.Position pos, ExternalPrincipal principal)` Constructs a principal instance for an external principal.
    `ParamPrincipal` | `principalParam(polyglot.util.Position pos, ParamInstance pi)`
    `java.lang.String` | `PrincipalUtilClassName()` Returns the name of the PrincipalUtil class.
    `void` | `processFAP(polyglot.types.ReferenceType rt, AccessPath path, JifContext A)`
    `protected void` | `processFAP(polyglot.types.ReferenceType rt, AccessPath path, JifContext A, java.util.Set<polyglot.types.ClassType> visited)`
    `void` | `processFAP(polyglot.types.VarInstance fi, AccessPath path, JifContext A)`
    `protected void` | `processFAP(polyglot.types.VarInstance fi, AccessPath path, JifContext A, java.util.Set<polyglot.types.ClassType> visited)`
    `boolean` | `promoteToFatal(polyglot.types.Type t)` Should this exception be promoted to a fatal error?
    `ProviderLabel` | `providerLabel(JifClassType ct)` Constructs a label for the provider of the given class type.
    `ProviderLabel` | `providerLabel(polyglot.util.Position position, JifClassType ct)`
    `protected LabelToJavaExpr` | `providerLabelTranslator()`
    `ReaderPolicy` | `readerPolicy(polyglot.util.Position pos, Principal owner, java.util.Collection<Principal> readers)`
    `ReaderPolicy` | `readerPolicy(polyglot.util.Position pos, Principal owner, Principal reader)`
    `java.lang.String` | `RuntimePackageName()` Returns the name of the Jif runtime package.
    `polyglot.types.Type` | `staticTarget(polyglot.types.Type t)`
    `protected polyglot.types.Type` | `strip(polyglot.types.Type type)`
    `protected polyglot.ext.param.types.Subst<ParamInstance,Param>` | `substImpl(java.util.Map<ParamInstance,? extends Param> substMap)`
    `ThisLabel` | `thisLabel(polyglot.types.ArrayType at)`
    `ThisLabel` | `thisLabel(JifClassType ct)`
    `ThisLabel` | `thisLabel(polyglot.util.Position pos, JifClassType ct)`
    `ThisLabel` | `thisLabel(polyglot.util.Position pos, polyglot.types.ReferenceType ct)`
    `Label` | `toLabel(Principal p)`
    `ConfPolicy` | `topConfPolicy(polyglot.util.Position pos)`
    `IntegPolicy` | `topIntegPolicy(polyglot.util.Position pos)`
    `Label` | `topLabel()`
    `Label` | `topLabel(polyglot.util.Position pos)`
    `TopPrincipal` | `topPrincipal(polyglot.util.Position pos)`
    `java.lang.String` | `translateClass(polyglot.types.Resolver c, polyglot.types.ClassType t)`
    `java.lang.String` | `translatePrimitive(polyglot.types.Resolver c, polyglot.types.PrimitiveType t)`
    `boolean` | `typeEquals(polyglot.types.Type t1, polyglot.types.Type t2)`
    `java.util.Collection<polyglot.types.Type>` | `uncheckedExceptions()`
    `polyglot.types.ClassType` | `uncheckedInstantiate(polyglot.util.Position pos, polyglot.ext.param.types.PClass<ParamInstance,Param> t, java.util.List<? extends Param> actuals)`
    `UnknownLabel` | `unknownLabel(polyglot.util.Position pos)`
    `Param` | `unknownParam(polyglot.util.Position pos)`
    `UnknownPrincipal` | `unknownPrincipal(polyglot.util.Position pos)`
    `polyglot.types.UnknownQualifier` | `unknownQualifier(polyglot.util.Position pos)`
    `polyglot.types.UnknownType` | `unknownType(polyglot.util.Position pos)`
    `polyglot.types.Type` | `unlabel(polyglot.types.Type type)` Remove the label from a type, if any.
    `AccessPath` | `varInstanceToAccessPath(polyglot.types.VarInstance vi, polyglot.util.Position pos)`
    `AccessPath` | `varInstanceToAccessPath(polyglot.types.VarInstance vi, java.lang.String name, polyglot.util.Position pos)`
    `WriterPolicy` | `writerPolicy(polyglot.util.Position pos, Principal owner, java.util.Collection<Principal> writers)`
    `WriterPolicy` | `writerPolicy(polyglot.util.Position pos, Principal owner, Principal writer)`
    `WritersToReadersLabel` | `writersToReadersLabel(polyglot.util.Position pos, Label L)`

    - ### Methods inherited from class polyglot.ext.param.types.ParamTypeSystem_c

      `instantiate, subst, subst`

    - ### Methods inherited from class polyglot.types.TypeSystem_c

      `Abstract, accessibleFromPackage, ArithmeticException, arrayOf, arrayOf, arrayOf, arrayOf, ArrayStoreException, assert_, assert_, AssertionError, Boolean, Byte, callValid, canOverride, Char, checkAccessFlags, checkClassConformance, checkClassFlagsConflict, checkConstructorFlags, checkCycles, checkCycles, checkFieldFlags, checkInitializerFlags, checkInterfaceFieldFlags, checkLocalClassFlags, checkLocalFlags, checkMemberClassFlags, checkMethodFlags, checkOverride, checkTopLevelClassFlags, Class, classAccessible, classAccessible, classAccessibleFromPackage, ClassCastException, classContextResolver, classContextResolver, Cloneable, createArrayType, createClassContextResolver, createClassType, createClassType, createClassType, createNewFlag, createNull, createPackage, createPackage, createPackageContextResolver, createPrimitive, Double, Error, Exception, extensionInfo, Final, findAcceptableConstructors, findAcceptableMethods, findConstructor, findConstructor, findConstructor, findField, findField, findField, findField, findFields, findImplementingMethod, findMemberClass, findMemberClass, findMemberClass, findMethod, findMethod, findMethod, findMostSpecificProcedures, findProcedure, flagsForBits, flagsForName, Float, forName, forName, getTransformedClassName, getTypeEncoderRootSet, hasAccessibleMethodNamed, hasEnclosingInstance, hasFormals, hasMethod, hasMethodNamed, implemented, importTable, importTable, initEnums, initFlags, initTypes, Int, Interface, interfaces, isAccessible, isAccessible, isAccessible, isAccessible, isCanonical, isEnclosed, isInherited, isMember, isSameConstructor, isSameMethod, isThrowable, isUncheckedException, legalAbstractMethodFlags, legalAccessFlags, legalConstructorFlags, legalFieldFlags, legalInitializerFlags, legalInterfaceFieldFlags, legalLocalClassFlags, legalLocalFlags, legalMemberClassFlags, legalMethodFlags, legalTopLevelClassFlags, listToString, load, loadedResolver, Long, methodCallValid, moreSpecific, mostSpecificComparator, Native, NoFlags, Null, NullPointerException, numericConversionValid, Object, OutOfBoundsException, overrides, packageContextResolver, packageContextResolver, packageContextResolver, packageEquals, packageExists, packageForName, packageForName, parsedResolver, placeHolder, placeHolder, Private, promote, promote, promoteNumeric, promoteNumeric, Protected, Public, restoreSystemResolver, returnTypesConsistent, RuntimeException, saveSystemResolver, Serializable, Short, Static, StrictFP, String, superType, Synchronized, systemResolver, Throwable, throwsSubset, toString, Transient, translateArray, translatePackage, typeForClass, typeForClass, typeForName, unknownPackage, Void, Volatile, wrapperTypeString`

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface polyglot.ext.param.types.ParamTypeSystem

      `instantiate, subst, subst`

    - ### Methods inherited from interface polyglot.types.TypeSystem

      `Abstract, ArithmeticException, arrayOf, arrayOf, arrayOf, arrayOf, ArrayStoreException, AssertionError, Boolean, Byte, callValid, canOverride, Char, checkAccessFlags, checkClassConformance, checkConstructorFlags, checkCycles, checkFieldFlags, checkInitializerFlags, checkInterfaceFieldFlags, checkLocalClassFlags, checkLocalFlags, checkMemberClassFlags, checkMethodFlags, checkOverride, checkTopLevelClassFlags, Class, classAccessible, classAccessible, classAccessibleFromPackage, ClassCastException, classContextResolver, classContextResolver, Cloneable, createClassContextResolver, createClassType, createClassType, createClassType, createNewFlag, createPackage, createPackage, createPackageContextResolver, Double, Error, Exception, extensionInfo, Final, findConstructor, findConstructor, findConstructor, findField, findField, findField, findField, findImplementingMethod, findMemberClass, findMemberClass, findMemberClass, findMethod, findMethod, findMethod, flagsForBits, Float, forName, getTransformedClassName, getTypeEncoderRootSet, hasAccessibleMethodNamed, hasEnclosingInstance, hasFormals, hasMethod, hasMethodNamed, implemented, importTable, importTable, Int, Interface, interfaces, isAccessible, isAccessible, isAccessible, isAccessible, isCanonical, isEnclosed, isInherited, isMember, isSameConstructor, isSameMethod, isThrowable, isUncheckedException, legalAbstractMethodFlags, legalAccessFlags, legalConstructorFlags, legalFieldFlags, legalInitializerFlags, legalInterfaceFieldFlags, legalLocalClassFlags, legalLocalFlags, legalMemberClassFlags, legalMethodFlags, legalTopLevelClassFlags, loadedResolver, Long, methodCallValid, moreSpecific, mostSpecificComparator, Native, NoFlags, Null, NullPointerException, numericConversionValid, Object, OutOfBoundsException, overrides, packageContextResolver, packageContextResolver, packageContextResolver, packageEquals, packageExists, packageForName, packageForName, parsedResolver, placeHolder, placeHolder, Private, promote, promote, Protected, Public, restoreSystemResolver, RuntimeException, saveSystemResolver, Serializable, Short, Static, StrictFP, String, superType, Synchronized, systemResolver, Throwable, throwsSubset, Transient, translateArray, translatePackage, typeForName, unknownPackage, Void, Volatile, wrapperTypeString`

- - ### Field Detail

    - #### jlts

          protected final polyglot.types.TypeSystem jlts

    - #### PRINCIPAL_

          protected polyglot.types.PrimitiveType PRINCIPAL_

    - #### LABEL_

          protected polyglot.types.PrimitiveType LABEL_

    - #### PRINCIPAL_CLASS_

          protected polyglot.types.Type PRINCIPAL_CLASS_

    - #### ltcu

          protected LabelTypeCheckUtil ltcu

  - ### Constructor Detail

    - #### JifTypeSystem_c

          public JifTypeSystem_c(polyglot.types.TypeSystem jlts)

  - ### Method Detail

    - #### deserializedClassInitializer

          public polyglot.types.LazyClassInitializer deserializedClassInitializer()

      Specified by:
        `deserializedClassInitializer` in interface `polyglot.types.TypeSystem`
      Overrides:
        `deserializedClassInitializer` in class `polyglot.types.TypeSystem_c`

    - #### createSolver

          public Solver createSolver(java.lang.String solverName)

      Description copied from interface: `JifTypeSystem`
      Returns a new label constraint system solver.
      Specified by:
        `createSolver` in interface `JifTypeSystem`

    - #### createEmptyLabelEnv

          protected LabelEnv createEmptyLabelEnv()

    - #### createLabelEnv

          public LabelEnv createLabelEnv()

      Specified by:
        `createLabelEnv` in interface `JifTypeSystem`

    - #### mutablePClass

          public polyglot.ext.param.types.MuPClass<ParamInstance,Param> mutablePClass(polyglot.util.Position pos)

      Specified by:
        `mutablePClass` in interface `polyglot.ext.param.types.ParamTypeSystem<ParamInstance,Param>`
      Overrides:
        `mutablePClass` in class `polyglot.ext.param.types.ParamTypeSystem_c<ParamInstance,Param>`

    - #### defaultClassInitializer

          public polyglot.types.LazyClassInitializer defaultClassInitializer()

      Specified by:
        `defaultClassInitializer` in interface `polyglot.types.TypeSystem`
      Overrides:
        `defaultClassInitializer` in class `polyglot.types.TypeSystem_c`

    - #### initialize

          public void initialize(polyglot.types.TopLevelResolver loadedResolver,
                                 polyglot.frontend.ExtensionInfo extInfo)
                          throws polyglot.types.SemanticException

      Initializes the type system and its internal constants.
      Specified by:
        `initialize` in interface `polyglot.types.TypeSystem`
      Overrides:
        `initialize` in class `polyglot.types.TypeSystem_c`
      Throws:
        `polyglot.types.SemanticException`

    - #### unknownType

          public polyglot.types.UnknownType unknownType(polyglot.util.Position pos)

      Specified by:
        `unknownType` in interface `polyglot.types.TypeSystem`
      Overrides:
        `unknownType` in class `polyglot.types.TypeSystem_c`

    - #### unknownQualifier

          public polyglot.types.UnknownQualifier unknownQualifier(polyglot.util.Position pos)

      Specified by:
        `unknownQualifier` in interface `polyglot.types.TypeSystem`
      Overrides:
        `unknownQualifier` in class `polyglot.types.TypeSystem_c`

    - #### PrincipalClassName

          public java.lang.String PrincipalClassName()

      Description copied from interface: `JifTypeSystem`
      Returns the name of the "principal" type. In Jif, this is "jif.lang.Principal". In languages that extend Jif, this may be different.
      Specified by:
        `PrincipalClassName` in interface `JifTypeSystem`

    - #### PrincipalUtilClassName

          public java.lang.String PrincipalUtilClassName()

      Description copied from interface: `JifTypeSystem`
      Returns the name of the PrincipalUtil class. In Jif, this is "jif.lang.PrincipalUtil". In languages that extend Jif, this may be different.
      Specified by:
        `PrincipalUtilClassName` in interface `JifTypeSystem`

    - #### LabelClassName

          public java.lang.String LabelClassName()

      Description copied from interface: `JifTypeSystem`
      Returns the name of the "label" type. In Jif, this is "jif.lang.Label". In languages that extend Jif, this may be different.
      Specified by:
        `LabelClassName` in interface `JifTypeSystem`

    - #### LabelUtilClassName

          public java.lang.String LabelUtilClassName()

      Description copied from interface: `JifTypeSystem`
      Returns the name of the LabelUtil class. In Jif, this is "jif.lang.LabelUtil". In languages that extend Jif, this may be different.
      Specified by:
        `LabelUtilClassName` in interface `JifTypeSystem`

    - #### RuntimePackageName

          public java.lang.String RuntimePackageName()

      Description copied from interface: `JifTypeSystem`
      Returns the name of the Jif runtime package. In Jif, this is "jif.runtime". In languages that extend Jif, this may be different.
      Specified by:
        `RuntimePackageName` in interface `JifTypeSystem`

    - #### Principal

          public polyglot.types.PrimitiveType Principal()

      Description copied from interface: `JifTypeSystem`
      Returns the "principal" type.
      Specified by:
        `Principal` in interface `JifTypeSystem`

    - #### PrincipalClass

          public polyglot.types.Type PrincipalClass()

      Description copied from interface: `JifTypeSystem`
      Returns the class jif.lang.Principal.
      Specified by:
        `PrincipalClass` in interface `JifTypeSystem`

    - #### Label

          public polyglot.types.PrimitiveType Label()

      Description copied from interface: `JifTypeSystem`
      Returns the "label" type.
      Specified by:
        `Label` in interface `JifTypeSystem`

    - #### createContext

          public JifContext createContext()

      Specified by:
        `createContext` in interface `JifTypeSystem`
      Specified by:
        `createContext` in interface `polyglot.types.TypeSystem`
      Overrides:
        `createContext` in class `polyglot.types.TypeSystem_c`

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.types.Type type)

      Specified by:
        `constArrayOf` in interface `JifTypeSystem`

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.util.Position pos,
                                             polyglot.types.Type type)

      Specified by:
        `constArrayOf` in interface `JifTypeSystem`

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.util.Position pos,
                                             polyglot.types.Type type,
                                             boolean castableToNonConst)

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.types.Type type,
                                             int dims)

      Specified by:
        `constArrayOf` in interface `JifTypeSystem`

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.util.Position pos,
                                             polyglot.types.Type type,
                                             int dims)

      Specified by:
        `constArrayOf` in interface `JifTypeSystem`

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.util.Position pos,
                                             polyglot.types.Type type,
                                             int dims,
                                             boolean castableToNonConst)

      Specified by:
        `constArrayOf` in interface `JifTypeSystem`

    - #### constArrayOf

          public ConstArrayType constArrayOf(polyglot.util.Position pos,
                                             polyglot.types.Type type,
                                             int dims,
                                             boolean castableToNonConst,
                                             boolean recurseIntoBaseType)

      Specified by:
        `constArrayOf` in interface `JifTypeSystem`

    - #### arrayType

          protected polyglot.types.ArrayType arrayType(polyglot.util.Position pos,
                                                       polyglot.types.Type type)

      Overrides:
        `arrayType` in class `polyglot.types.TypeSystem_c`

    - #### initializerInstance

          public polyglot.types.InitializerInstance initializerInstance(polyglot.util.Position pos,
                                                                        polyglot.types.ClassType container,
                                                                        polyglot.types.Flags flags)

      Specified by:
        `initializerInstance` in interface `polyglot.types.TypeSystem`
      Overrides:
        `initializerInstance` in class `polyglot.types.TypeSystem_c`

    - #### fieldInstance

          public polyglot.types.FieldInstance fieldInstance(polyglot.util.Position pos,
                                                            polyglot.types.ReferenceType container,
                                                            polyglot.types.Flags flags,
                                                            polyglot.types.Type type,
                                                            java.lang.String name)

      Specified by:
        `fieldInstance` in interface `polyglot.types.TypeSystem`
      Overrides:
        `fieldInstance` in class `polyglot.types.TypeSystem_c`

    - #### localInstance

          public polyglot.types.LocalInstance localInstance(polyglot.util.Position pos,
                                                            polyglot.types.Flags flags,
                                                            polyglot.types.Type type,
                                                            java.lang.String name)

      Specified by:
        `localInstance` in interface `polyglot.types.TypeSystem`
      Overrides:
        `localInstance` in class `polyglot.types.TypeSystem_c`

    - #### constructorInstance

          public polyglot.types.ConstructorInstance constructorInstance(polyglot.util.Position pos,
                                                                        polyglot.types.ClassType container,
                                                                        polyglot.types.Flags flags,
                                                                        java.util.List<? extends polyglot.types.Type> formalTypes,
                                                                        java.util.List<? extends polyglot.types.Type> excTypes)

      Specified by:
        `constructorInstance` in interface `polyglot.types.TypeSystem`
      Overrides:
        `constructorInstance` in class `polyglot.types.TypeSystem_c`

    - #### jifConstructorInstance

          public JifConstructorInstance jifConstructorInstance(polyglot.util.Position pos,
                                                               polyglot.types.ClassType container,
                                                               polyglot.types.Flags flags,
                                                               Label startLabel,
                                                               boolean isDefaultStartLabel,
                                                               Label returnLabel,
                                                               boolean isDefaultReturnLabel,
                                                               java.util.List<? extends polyglot.types.Type> formalTypes,
                                                               java.util.List<Label> formalArgLabels,
                                                               java.util.List<? extends polyglot.types.Type> excTypes,
                                                               java.util.List<Assertion> constraints)

    - #### methodInstance

          public polyglot.types.MethodInstance methodInstance(polyglot.util.Position pos,
                                                              polyglot.types.ReferenceType container,
                                                              polyglot.types.Flags flags,
                                                              polyglot.types.Type returnType,
                                                              java.lang.String name,
                                                              java.util.List<? extends polyglot.types.Type> formalTypes,
                                                              java.util.List<? extends polyglot.types.Type> excTypes)

      Specified by:
        `methodInstance` in interface `polyglot.types.TypeSystem`
      Overrides:
        `methodInstance` in class `polyglot.types.TypeSystem_c`

    - #### jifMethodInstance

          public JifMethodInstance jifMethodInstance(polyglot.util.Position pos,
                                                     polyglot.types.ReferenceType container,
                                                     polyglot.types.Flags flags,
                                                     polyglot.types.Type returnType,
                                                     java.lang.String name,
                                                     Label startLabel,
                                                     boolean isDefaultStartLabel,
                                                     java.util.List<? extends polyglot.types.Type> formalTypes,
                                                     java.util.List<Label> formalArgLabels,
                                                     Label endLabel,
                                                     boolean isDefaultEndLabel,
                                                     java.util.List<? extends polyglot.types.Type> excTypes,
                                                     java.util.List<Assertion> constraints)

      Specified by:
        `jifMethodInstance` in interface `JifTypeSystem`

    - #### paramInstance

          public ParamInstance paramInstance(polyglot.util.Position pos,
                                             JifClassType container,
                                             ParamInstance.Kind kind,
                                             java.lang.String name)

      Description copied from interface: `JifTypeSystem`
      Constructs a parameter instance for a class parameter declaration
      Specified by:
        `paramInstance` in interface `JifTypeSystem`

    - #### principalInstance

          public PrincipalInstance principalInstance(polyglot.util.Position pos,
                                                     ExternalPrincipal principal)

      Description copied from interface: `JifTypeSystem`
      Constructs a principal instance for an external principal.
      Specified by:
        `principalInstance` in interface `JifTypeSystem`

    - #### descendsFrom

          public boolean descendsFrom(polyglot.types.Type child,
                                      polyglot.types.Type ancestor)

      Specified by:
        `descendsFrom` in interface `polyglot.types.TypeSystem`
      Overrides:
        `descendsFrom` in class `polyglot.types.TypeSystem_c`

    - #### isSubtype

          public boolean isSubtype(polyglot.types.Type child,
                                   polyglot.types.Type ancestor)

      Specified by:
        `isSubtype` in interface `polyglot.types.TypeSystem`
      Overrides:
        `isSubtype` in class `polyglot.types.TypeSystem_c`

    - #### isCastValid

          public boolean isCastValid(polyglot.types.Type fromType,
                                     polyglot.types.Type toType)

      Specified by:
        `isCastValid` in interface `polyglot.types.TypeSystem`
      Overrides:
        `isCastValid` in class `polyglot.types.TypeSystem_c`

    - #### isImplicitCastValid

          public boolean isImplicitCastValid(polyglot.types.Type fromType,
                                             polyglot.types.Type toType)

      Specified by:
        `isImplicitCastValid` in interface `polyglot.types.TypeSystem`
      Overrides:
        `isImplicitCastValid` in class `polyglot.types.TypeSystem_c`

    - #### staticTarget

          public polyglot.types.Type staticTarget(polyglot.types.Type t)

      Specified by:
        `staticTarget` in interface `polyglot.types.TypeSystem`
      Overrides:
        `staticTarget` in class `polyglot.types.TypeSystem_c`

    - #### equalsNoStrip

          public boolean equalsNoStrip(polyglot.types.TypeObject t1,
                                       polyglot.types.TypeObject t2)

      Description copied from interface: `JifTypeSystem`
      Compares t1 to t2 without stripping off all the parameters and labels
      Specified by:
        `equalsNoStrip` in interface `JifTypeSystem`

    - #### equalsStrip

          public boolean equalsStrip(polyglot.types.TypeObject t1,
                                     polyglot.types.TypeObject t2)

      Description copied from interface: `JifTypeSystem`
      Compares t1 to t2, stripping off all the parameters and labels
      Specified by:
        `equalsStrip` in interface `JifTypeSystem`

    - #### equals

          public boolean equals(polyglot.types.TypeObject t1,
                                polyglot.types.TypeObject t2)

      Specified by:
        `equals` in interface `polyglot.types.TypeSystem`
      Overrides:
        `equals` in class `polyglot.types.TypeSystem_c`

    - #### typeEquals

          public boolean typeEquals(polyglot.types.Type t1,
                                    polyglot.types.Type t2)

      Specified by:
        `typeEquals` in interface `polyglot.types.TypeSystem`
      Overrides:
        `typeEquals` in class `polyglot.types.TypeSystem_c`

    - #### leastCommonAncestorSubtype

          protected polyglot.types.Type leastCommonAncestorSubtype(polyglot.types.Type subtype,
                                                                   polyglot.types.Type supertype)

      Find out if the least common ancestor of subtype and supertype is supertype, given that strip(subtype) is a sub type of strip(supertype). i.e. check their parameters are appropriate.
      Returns:
        supertype if supertype is the least common ancestor of subtype and supertype, null otherwise.

    - #### leastCommonAncestor

          public polyglot.types.Type leastCommonAncestor(polyglot.types.Type type1,
                                                         polyglot.types.Type type2)
                                                  throws polyglot.types.SemanticException

      Override the superclass implementation, to handle label and principal parameters, and array base types correctly.
      Specified by:
        `leastCommonAncestor` in interface `polyglot.types.TypeSystem`
      Overrides:
        `leastCommonAncestor` in class `polyglot.types.TypeSystem_c`
      Throws:
        `polyglot.types.SemanticException`

    - #### numericConversionValid

          public boolean numericConversionValid(polyglot.types.Type t,
                                                java.lang.Object value)

      Specified by:
        `numericConversionValid` in interface `polyglot.types.TypeSystem`
      Overrides:
        `numericConversionValid` in class `polyglot.types.TypeSystem_c`

    - #### createClassType

          public polyglot.types.ParsedClassType createClassType(polyglot.types.LazyClassInitializer init,
                                                                polyglot.frontend.Source fromSource)

      Specified by:
        `createClassType` in interface `polyglot.types.TypeSystem`
      Overrides:
        `createClassType` in class `polyglot.types.TypeSystem_c`

    - #### defaultPackageImports

          public java.util.List<java.lang.String> defaultPackageImports()

      Specified by:
        `defaultPackageImports` in interface `polyglot.types.TypeSystem`
      Overrides:
        `defaultPackageImports` in class `polyglot.types.TypeSystem_c`

    - #### classFileLazyClassInitializer

          public polyglot.types.reflect.ClassFileLazyClassInitializer classFileLazyClassInitializer(polyglot.types.reflect.ClassFile clazz)

      Specified by:
        `classFileLazyClassInitializer` in interface `polyglot.types.TypeSystem`
      Overrides:
        `classFileLazyClassInitializer` in class `polyglot.types.TypeSystem_c`

    - #### labeledType

          public LabeledType labeledType(polyglot.util.Position pos,
                                         polyglot.types.Type type,
                                         Label label)

      Jif specific stuff
      Specified by:
        `labeledType` in interface `JifTypeSystem`

    - #### pathMap

          public PathMap pathMap()

      Specified by:
        `pathMap` in interface `JifTypeSystem`

    - #### pathMap

          public PathMap pathMap(Path path,
                                 Label L)

      Specified by:
        `pathMap` in interface `JifTypeSystem`

    - #### exceptionPath

          public ExceptionPath exceptionPath(polyglot.types.Type type)

      Specified by:
        `exceptionPath` in interface `JifTypeSystem`

    - #### gotoPath

          public Path gotoPath(polyglot.ast.Branch.Kind kind,
                               java.lang.String target)

      Specified by:
        `gotoPath` in interface `JifTypeSystem`

    - #### unknownParam

          public Param unknownParam(polyglot.util.Position pos)

      Specified by:
        `unknownParam` in interface `JifTypeSystem`

    - #### nullInstantiate

          public polyglot.types.ClassType nullInstantiate(polyglot.util.Position pos,
                                                          polyglot.ext.param.types.PClass<ParamInstance,Param> pc)

      Specified by:
        `nullInstantiate` in interface `JifTypeSystem`

    - #### checkInstantiation

          public void checkInstantiation(polyglot.util.Position pos,
                                         polyglot.ext.param.types.PClass<ParamInstance,Param> t,
                                         java.util.List<? extends Param> args)
                                  throws polyglot.types.SemanticException

      Overrides:
        `checkInstantiation` in class `polyglot.ext.param.types.ParamTypeSystem_c<ParamInstance,Param>`
      Throws:
        `polyglot.types.SemanticException`

    - #### uncheckedInstantiate

          public polyglot.types.ClassType uncheckedInstantiate(polyglot.util.Position pos,
                                                               polyglot.ext.param.types.PClass<ParamInstance,Param> t,
                                                               java.util.List<? extends Param> actuals)

      Overrides:
        `uncheckedInstantiate` in class `polyglot.ext.param.types.ParamTypeSystem_c<ParamInstance,Param>`

    - #### substImpl

          protected polyglot.ext.param.types.Subst<ParamInstance,Param> substImpl(java.util.Map<ParamInstance,? extends Param> substMap)

      Overrides:
        `substImpl` in class `polyglot.ext.param.types.ParamTypeSystem_c<ParamInstance,Param>`

    - #### fatalException

          public polyglot.types.ClassType fatalException()

      Specified by:
        `fatalException` in interface `JifTypeSystem`

    - #### freshLabelVariable

          public VarLabel freshLabelVariable(polyglot.util.Position pos,
                                             java.lang.String s,
                                             java.lang.String description)

      Specified by:
        `freshLabelVariable` in interface `JifTypeSystem`

    - #### freshPrincipalVariable

          public VarPrincipal freshPrincipalVariable(polyglot.util.Position pos,
                                                     java.lang.String s,
                                                     java.lang.String description)

      Specified by:
        `freshPrincipalVariable` in interface `JifTypeSystem`

    - #### principalParam

          public ParamPrincipal principalParam(polyglot.util.Position pos,
                                               ParamInstance pi)

      Specified by:
        `principalParam` in interface `JifTypeSystem`

    - #### dynamicPrincipal

          public DynamicPrincipal dynamicPrincipal(polyglot.util.Position pos,
                                                   AccessPath path)

      Specified by:
        `dynamicPrincipal` in interface `JifTypeSystem`

    - #### dynamicPrincipalTranslator

          protected PrincipalToJavaExpr dynamicPrincipalTranslator()

    - #### pathToPrincipal

          public Principal pathToPrincipal(polyglot.util.Position pos,
                                           AccessPath path)

      Specified by:
        `pathToPrincipal` in interface `JifTypeSystem`

    - #### externalPrincipal

          public ExternalPrincipal externalPrincipal(polyglot.util.Position pos,
                                                     java.lang.String name)

      Specified by:
        `externalPrincipal` in interface `JifTypeSystem`

    - #### unknownPrincipal

          public UnknownPrincipal unknownPrincipal(polyglot.util.Position pos)

      Specified by:
        `unknownPrincipal` in interface `JifTypeSystem`

    - #### topPrincipal

          public TopPrincipal topPrincipal(polyglot.util.Position pos)

      Specified by:
        `topPrincipal` in interface `JifTypeSystem`

    - #### bottomPrincipal

          public BottomPrincipal bottomPrincipal(polyglot.util.Position pos)

      Specified by:
        `bottomPrincipal` in interface `JifTypeSystem`

    - #### conjunctivePrincipal

          public Principal conjunctivePrincipal(polyglot.util.Position pos,
                                                Principal l,
                                                Principal r)

      Specified by:
        `conjunctivePrincipal` in interface `JifTypeSystem`

    - #### conjunctivePrincipal

          public Principal conjunctivePrincipal(polyglot.util.Position pos,
                                                java.util.Collection<Principal> ps)

      Specified by:
        `conjunctivePrincipal` in interface `JifTypeSystem`

    - #### conjunctivePrincipalTranslator

          public PrincipalToJavaExpr conjunctivePrincipalTranslator()

      Specified by:
        `conjunctivePrincipalTranslator` in interface `JifTypeSystem`
      Returns:
        class for translating conjunctive principals to java expressions

    - #### disjunctivePrincipal

          public Principal disjunctivePrincipal(polyglot.util.Position pos,
                                                Principal l,
                                                Principal r)

      Specified by:
        `disjunctivePrincipal` in interface `JifTypeSystem`

    - #### disjunctivePrincipal

          public Principal disjunctivePrincipal(polyglot.util.Position pos,
                                                java.util.Collection<Principal> ps)

      Specified by:
        `disjunctivePrincipal` in interface `JifTypeSystem`

    - #### disjunctivePrincipalTranslator

          public PrincipalToJavaExpr disjunctivePrincipalTranslator()

      Specified by:
        `disjunctivePrincipalTranslator` in interface `JifTypeSystem`
      Returns:
        class for translating disjunctive principals to java expressions

    - #### paramLabelTranslator

          public LabelToJavaExpr paramLabelTranslator()

      Specified by:
        `paramLabelTranslator` in interface `JifTypeSystem`
      Returns:
        object for translating label parameters to Java expressions

    - #### paramPrincipalTranslator

          public PrincipalToJavaExpr paramPrincipalTranslator()

      Specified by:
        `paramPrincipalTranslator` in interface `JifTypeSystem`
      Returns:
        object for translating principal parameters to Java expressions

    - #### topLabel

          public Label topLabel(polyglot.util.Position pos)

      Specified by:
        `topLabel` in interface `JifTypeSystem`
      Returns:
        the label representing private, untrusted information ({⊤→⊤;⊥←⊥}).

    - #### topLabel

          public Label topLabel()

      Specified by:
        `topLabel` in interface `JifTypeSystem`
      Returns:
        the label representing private, untrusted information ({⊤→⊤;⊥←⊥}).

    - #### bottomLabel

          public Label bottomLabel(polyglot.util.Position pos)

      Specified by:
        `bottomLabel` in interface `JifTypeSystem`
      Returns:
        the label representing public, trusted information ({⊥→⊥;⊤←⊤}).

    - #### bottomLabel

          public Label bottomLabel()

      Specified by:
        `bottomLabel` in interface `JifTypeSystem`
      Returns:
        the label representing public, trusted information ({⊥→⊥;⊤←⊤}).

    - #### providerLabel

          public ProviderLabel providerLabel(JifClassType ct)

      Description copied from interface: `JifTypeSystem`
      Constructs a label for the provider of the given class type. This is intended to be used only when initializing JifClassTypes. All other callers should use providerLabel(Position, JifClassType).
      Specified by:
        `providerLabel` in interface `JifTypeSystem`

    - #### providerLabel

          public ProviderLabel providerLabel(polyglot.util.Position position,
                                             JifClassType ct)

      Specified by:
        `providerLabel` in interface `JifTypeSystem`
      Returns:
        a label representing the provider of the given class type.

    - #### providerLabelTranslator

          protected LabelToJavaExpr providerLabelTranslator()

    - #### noComponentsLabel

          public Label noComponentsLabel()

      Specified by:
        `noComponentsLabel` in interface `JifTypeSystem`
      Returns:
        the label representing public, untrusted information ({⊥→⊥;⊥←⊥}).

    - #### noComponentsLabel

          public Label noComponentsLabel(polyglot.util.Position pos)

      Specified by:
        `noComponentsLabel` in interface `JifTypeSystem`
      Returns:
        the label representing public, untrusted information ({⊥→⊥;⊥←⊥}).

    - #### notTaken

          public Label notTaken(polyglot.util.Position pos)

      Specified by:
        `notTaken` in interface `JifTypeSystem`

    - #### notTaken

          public Label notTaken()

      Specified by:
        `notTaken` in interface `JifTypeSystem`

    - #### covariantLabel

          public CovariantParamLabel covariantLabel(polyglot.util.Position pos,
                                                    ParamInstance pi)

      Specified by:
        `covariantLabel` in interface `JifTypeSystem`

    - #### paramLabel

          public ParamLabel paramLabel(polyglot.util.Position pos,
                                       ParamInstance pi)

      Specified by:
        `paramLabel` in interface `JifTypeSystem`

    - #### readerPolicy

          public ReaderPolicy readerPolicy(polyglot.util.Position pos,
                                           Principal owner,
                                           Principal reader)

      Specified by:
        `readerPolicy` in interface `JifTypeSystem`

    - #### readerPolicy

          public ReaderPolicy readerPolicy(polyglot.util.Position pos,
                                           Principal owner,
                                           java.util.Collection<Principal> readers)

      Specified by:
        `readerPolicy` in interface `JifTypeSystem`

    - #### writerPolicy

          public WriterPolicy writerPolicy(polyglot.util.Position pos,
                                           Principal owner,
                                           Principal writer)

      Specified by:
        `writerPolicy` in interface `JifTypeSystem`

    - #### writerPolicy

          public WriterPolicy writerPolicy(polyglot.util.Position pos,
                                           Principal owner,
                                           java.util.Collection<Principal> writers)

      Specified by:
        `writerPolicy` in interface `JifTypeSystem`

    - #### bottomConfPolicy

          public ConfPolicy bottomConfPolicy(polyglot.util.Position pos)

      Specified by:
        `bottomConfPolicy` in interface `JifTypeSystem`
      Returns:
        the confidentiality policy representing public information (⊥→⊥).

    - #### bottomIntegPolicy

          public IntegPolicy bottomIntegPolicy(polyglot.util.Position pos)

      Specified by:
        `bottomIntegPolicy` in interface `JifTypeSystem`
      Returns:
        the integrity policy representing trusted information (⊤←⊤).

    - #### topConfPolicy

          public ConfPolicy topConfPolicy(polyglot.util.Position pos)

      Specified by:
        `topConfPolicy` in interface `JifTypeSystem`
      Returns:
        the confidentiality policy representing private information (⊤→⊤).

    - #### topIntegPolicy

          public IntegPolicy topIntegPolicy(polyglot.util.Position pos)

      Specified by:
        `topIntegPolicy` in interface `JifTypeSystem`
      Returns:
        the integrity policy representing untrusted information (⊥←⊥).

    - #### joinLabel

          public Label joinLabel(polyglot.util.Position pos,
                                 java.util.Set<Label> components)

      Specified by:
        `joinLabel` in interface `JifTypeSystem`

    - #### joinLabelTranslator

          public LabelToJavaExpr joinLabelTranslator()

    - #### meetLabel

          public Label meetLabel(polyglot.util.Position pos,
                                 java.util.Set<Label> components)

      Specified by:
        `meetLabel` in interface `JifTypeSystem`

    - #### meetLabelTranslator

          public LabelToJavaExpr meetLabelTranslator()

    - #### dynamicLabel

          public DynamicLabel dynamicLabel(polyglot.util.Position pos,
                                           AccessPath path)

      Specified by:
        `dynamicLabel` in interface `JifTypeSystem`

    - #### pathToLabel

          public Label pathToLabel(polyglot.util.Position pos,
                                   AccessPath path)

      Specified by:
        `pathToLabel` in interface `JifTypeSystem`

    - #### dynamicLabelTranslator

          protected LabelToJavaExpr dynamicLabelTranslator()

    - #### argLabel

          public ArgLabel argLabel(polyglot.util.Position pos,
                                   polyglot.types.LocalInstance vi,
                                   polyglot.types.CodeInstance ci)

      Specified by:
        `argLabel` in interface `JifTypeSystem`

    - #### argLabel

          public ArgLabel argLabel(polyglot.util.Position pos,
                                   ParamInstance pi)

      Specified by:
        `argLabel` in interface `JifTypeSystem`

    - #### callSitePCLabel

          public Label callSitePCLabel(JifProcedureInstance pi)

      Specified by:
        `callSitePCLabel` in interface `JifTypeSystem`

    - #### thisLabel

          public ThisLabel thisLabel(JifClassType ct)

      Specified by:
        `thisLabel` in interface `JifTypeSystem`

    - #### thisLabel

          public ThisLabel thisLabel(polyglot.types.ArrayType at)

      Specified by:
        `thisLabel` in interface `JifTypeSystem`

    - #### thisLabel

          public ThisLabel thisLabel(polyglot.util.Position pos,
                                     JifClassType ct)

      Specified by:
        `thisLabel` in interface `JifTypeSystem`

    - #### thisLabel

          public ThisLabel thisLabel(polyglot.util.Position pos,
                                     polyglot.types.ReferenceType ct)

    - #### unknownLabel

          public UnknownLabel unknownLabel(polyglot.util.Position pos)

      Specified by:
        `unknownLabel` in interface `JifTypeSystem`

    - #### pairLabel

          public PairLabel pairLabel(polyglot.util.Position pos,
                                     ConfPolicy confPol,
                                     IntegPolicy integPol)

      Specified by:
        `pairLabel` in interface `JifTypeSystem`

    - #### pairLabelTranslator

          protected LabelToJavaExpr pairLabelTranslator()

    - #### writersToReadersLabel

          public WritersToReadersLabel writersToReadersLabel(polyglot.util.Position pos,
                                                             Label L)

      Specified by:
        `writersToReadersLabel` in interface `JifTypeSystem`

    - #### actsForConstraint

          public <Actor extends ActsForParam,Granter extends ActsForParam> ActsForConstraint<Actor,Granter> actsForConstraint(polyglot.util.Position pos,
                                                                                                                              Actor actor,
                                                                                                                              Granter granter,
                                                                                                                              boolean isEquiv)

      Description copied from interface: `JifTypeSystem`
      Construct an acts-for constraint.
      Specified by:
        `actsForConstraint` in interface `JifTypeSystem`

    - #### actsForConstraintTranslator

          protected ActsForConstraintToJavaExpr actsForConstraintTranslator()

    - #### labelLeAssertion

          public LabelLeAssertion labelLeAssertion(polyglot.util.Position pos,
                                                   Label lhs,
                                                   Label rhs)

      Description copied from interface: `JifTypeSystem`
      Construct an acts-for constraint.
      Specified by:
        `labelLeAssertion` in interface `JifTypeSystem`

    - #### labelLeAssertionTranslator

          protected LabelLeAssertionToJavaExpr labelLeAssertionTranslator()

    - #### authConstraint

          public AuthConstraint authConstraint(polyglot.util.Position pos,
                                               java.util.List<Principal> principals)

      Description copied from interface: `JifTypeSystem`
      Construct an authority constraint.
      Specified by:
        `authConstraint` in interface `JifTypeSystem`

    - #### autoEndorseConstraint

          public AutoEndorseConstraint autoEndorseConstraint(polyglot.util.Position pos,
                                                             Label endorseTo)

      Description copied from interface: `JifTypeSystem`
      Construct an autoendorse constraint.
      Specified by:
        `autoEndorseConstraint` in interface `JifTypeSystem`

    - #### callerConstraint

          public CallerConstraint callerConstraint(polyglot.util.Position pos,
                                                   java.util.List<Principal> principals)

      Description copied from interface: `JifTypeSystem`
      Construct a caller constraint.
      Specified by:
        `callerConstraint` in interface `JifTypeSystem`

    - #### labelOfField

          public Label labelOfField(polyglot.types.FieldInstance vi,
                                    Label pc)

      Description copied from interface: `JifTypeSystem`
      Get the label of the field, folding in the PC if appropriate.
      Specified by:
        `labelOfField` in interface `JifTypeSystem`

    - #### labelOfLocal

          public Label labelOfLocal(polyglot.types.LocalInstance vi,
                                    Label pc)

      Description copied from interface: `JifTypeSystem`
      Get the label of the local, folding in the PC if appropriate.
      Specified by:
        `labelOfLocal` in interface `JifTypeSystem`

    - #### labelOfType

          public Label labelOfType(polyglot.types.Type type)

      Description copied from interface: `JifTypeSystem`
      Get the label of the type, or bottom if unlabeled
      Specified by:
        `labelOfType` in interface `JifTypeSystem`

    - #### labelOfType

          public Label labelOfType(polyglot.types.Type type,
                                   Label defaultLabel)

      Description copied from interface: `JifTypeSystem`
      Get the label of the type, or `defaultLabel` if unlabeled.
      Specified by:
        `labelOfType` in interface `JifTypeSystem`

    - #### strip

          protected polyglot.types.Type strip(polyglot.types.Type type)

    - #### unlabel

          public polyglot.types.Type unlabel(polyglot.types.Type type)

      Description copied from interface: `JifTypeSystem`
      Remove the label from a type, if any.
      Specified by:
        `unlabel` in interface `JifTypeSystem`

    - #### isLabel

          public boolean isLabel(polyglot.types.Type type)

      Description copied from interface: `JifTypeSystem`
      Tests if the type is "label".
      Specified by:
        `isLabel` in interface `JifTypeSystem`

    - #### isPrincipal

          public boolean isPrincipal(polyglot.types.Type type)

      Description copied from interface: `JifTypeSystem`
      Tests if the type is "principal".
      Specified by:
        `isPrincipal` in interface `JifTypeSystem`

    - #### isLabeled

          public boolean isLabeled(polyglot.types.Type type)

      Description copied from interface: `JifTypeSystem`
      Returns true if the type is labeled.
      Specified by:
        `isLabeled` in interface `JifTypeSystem`

    - #### isSignature

          public boolean isSignature(polyglot.types.Type type)

      Returns true if the type is a Jif class (will return false if the type is just a jif signature for a java class). All class types are JifClasses unless they are signatures for java classes. Currently we determine this by assuming that Jif "source code" for Java classes have been given a private static field, named "__JIF_SIG_OF_JAVA_CLASS$20030619". Ideally, in the future we would have sufficient infrastructure in Polyglot to simply provide a signature for a Java class, and be able to detect this.
      Specified by:
        `isSignature` in interface `JifTypeSystem`

    - #### isMarkerFieldName

          public boolean isMarkerFieldName(java.lang.String s)

      Description copied from interface: `JifTypeSystem`
      Is the string s a special marker field name?
      Specified by:
        `isMarkerFieldName` in interface `JifTypeSystem`

    - #### isParamsRuntimeRep

          public boolean isParamsRuntimeRep(polyglot.types.Type t)

      Description copied from interface: `JifTypeSystem`
      Returns true if the type is a Jif class, or if it is a non-Jif class that represents parameters at runtime.
      Specified by:
        `isParamsRuntimeRep` in interface `JifTypeSystem`

    - #### hasUntrustedAncestor

          public polyglot.types.ClassType hasUntrustedAncestor(polyglot.types.Type t)

      Check if the class has an untrusted non-jif ancestor. An untrusted non-jif ancestor is any non-jif ancestor whose constructors may potentially access a final field (which may be on a subclass) before that field has been intitialized. A special marker field is used in Jif signature files for Java classes to declare that all constructors of the Java file are okay.
      Specified by:
        `hasUntrustedAncestor` in interface `JifTypeSystem`
      Parameters:
        `t` - Type to check
      Returns:
        null if ct has no untrusted non-Jif ancestor, and the ClassType of an untrusted non-Jif ancestor otherwise.

    - #### hasSafeConstructors

          public boolean hasSafeConstructors(polyglot.types.ClassType ct)

      Check if the class has safe constructors, that is, if the constructors of the class definitely do not access a final field (possibly on a subclass) before that field has been initalized. All Jif classes are safe; Java classes can be explicitly marked as safe by a special marker field.

    - #### canCoerceToString

          public boolean canCoerceToString(polyglot.types.Type t,
                                           polyglot.types.Context c)

      In general, type t can be coerced to a String if t is a String, a primitive, or it has a toString() method.
      Specified by:
        `canCoerceToString` in interface `polyglot.types.TypeSystem`
      Overrides:
        `canCoerceToString` in class `polyglot.types.TypeSystem_c`

    - #### join

          public Label join(Label L1,
                            Label L2)

      Description copied from interface: `JifTypeSystem`
      Returns the join of L1 and L2.
      Specified by:
        `join` in interface `JifTypeSystem`

    - #### meet

          public Label meet(Label L1,
                            Label L2)

      Description copied from interface: `JifTypeSystem`
      Returns the meet of L1 and L2.
      Specified by:
        `meet` in interface `JifTypeSystem`

    - #### actsFor

          public boolean actsFor(Principal p,
                                 Principal q)

      Description copied from interface: `JifTypeSystem`
      Returns true iff p actsfor q in the empty environment.
      Specified by:
        `actsFor` in interface `JifTypeSystem`

    - #### leq

          public boolean leq(Label L1,
                             Label L2)

      Description copied from interface: `JifTypeSystem`
      Returns true iff L1 <= L2 in the empty environment.
      Specified by:
        `leq` in interface `JifTypeSystem`

    - #### leq

          public boolean leq(Policy p1,
                             Policy p2)

      Specified by:
        `leq` in interface `JifTypeSystem`

    - #### joinConfPolicy

          public ConfPolicy joinConfPolicy(polyglot.util.Position pos,
                                           java.util.Set<ConfPolicy> components)

      Specified by:
        `joinConfPolicy` in interface `JifTypeSystem`

    - #### joinIntegPolicy

          public IntegPolicy joinIntegPolicy(polyglot.util.Position pos,
                                             java.util.Set<IntegPolicy> components)

      Specified by:
        `joinIntegPolicy` in interface `JifTypeSystem`

    - #### meetConfPolicy

          public ConfPolicy meetConfPolicy(polyglot.util.Position pos,
                                           java.util.Set<ConfPolicy> components)

      Specified by:
        `meetConfPolicy` in interface `JifTypeSystem`

    - #### meetIntegPolicy

          public IntegPolicy meetIntegPolicy(polyglot.util.Position pos,
                                             java.util.Set<IntegPolicy> components)

      Specified by:
        `meetIntegPolicy` in interface `JifTypeSystem`

    - #### join

          public ConfPolicy join(ConfPolicy p1,
                                 ConfPolicy p2)

      Specified by:
        `join` in interface `JifTypeSystem`

    - #### join

          public IntegPolicy join(IntegPolicy p1,
                                  IntegPolicy p2)

      Specified by:
        `join` in interface `JifTypeSystem`

    - #### meet

          public ConfPolicy meet(ConfPolicy p1,
                                 ConfPolicy p2)

      Specified by:
        `meet` in interface `JifTypeSystem`

    - #### meet

          public IntegPolicy meet(IntegPolicy p1,
                                  IntegPolicy p2)

      Specified by:
        `meet` in interface `JifTypeSystem`

    - #### confProjection

          public ConfPolicy confProjection(Label L)

      Specified by:
        `confProjection` in interface `JifTypeSystem`

    - #### integProjection

          public IntegPolicy integProjection(Label L)

      Specified by:
        `integProjection` in interface `JifTypeSystem`

    - #### translateClass

          public java.lang.String translateClass(polyglot.types.Resolver c,
                                                 polyglot.types.ClassType t)

      Specified by:
        `translateClass` in interface `polyglot.types.TypeSystem`
      Overrides:
        `translateClass` in class `polyglot.types.TypeSystem_c`

    - #### translatePrimitive

          public java.lang.String translatePrimitive(polyglot.types.Resolver c,
                                                     polyglot.types.PrimitiveType t)

      Specified by:
        `translatePrimitive` in interface `polyglot.types.TypeSystem`
      Overrides:
        `translatePrimitive` in class `polyglot.types.TypeSystem_c`

    - #### abstractSuperInterfaces

          public java.util.List<polyglot.types.ReferenceType> abstractSuperInterfaces(polyglot.types.ReferenceType rt)

      Description copied from interface: `JifTypeSystem`
      Exposes utility method of TypeSystem_c
      Specified by:
        `abstractSuperInterfaces` in interface `JifTypeSystem`
      Overrides:
        `abstractSuperInterfaces` in class `polyglot.types.TypeSystem_c`

    - #### isAccessible

          public boolean isAccessible(polyglot.types.MemberInstance mi,
                                      polyglot.types.ClassType contextClass)

      Description copied from interface: `JifTypeSystem`
      Exposes utility method of TypeSystem_c
      Specified by:
        `isAccessible` in interface `JifTypeSystem`
      Specified by:
        `isAccessible` in interface `polyglot.types.TypeSystem`
      Overrides:
        `isAccessible` in class `polyglot.types.TypeSystem_c`

    - #### primitiveForName

          public polyglot.types.PrimitiveType primitiveForName(java.lang.String name)
                                                        throws polyglot.types.SemanticException

      Specified by:
        `primitiveForName` in interface `polyglot.types.TypeSystem`
      Overrides:
        `primitiveForName` in class `polyglot.types.TypeSystem_c`
      Throws:
        `polyglot.types.SemanticException`

    - #### uncheckedExceptions

          public java.util.Collection<polyglot.types.Type> uncheckedExceptions()

      Specified by:
        `uncheckedExceptions` in interface `polyglot.types.TypeSystem`
      Overrides:
        `uncheckedExceptions` in class `polyglot.types.TypeSystem_c`

    - #### defaultSignature

          public DefaultSignature defaultSignature()

      Specified by:
        `defaultSignature` in interface `JifTypeSystem`

    - #### defaultConstructor

          public polyglot.types.ConstructorInstance defaultConstructor(polyglot.util.Position pos,
                                                                       polyglot.types.ClassType container)

      Specified by:
        `defaultConstructor` in interface `polyglot.types.TypeSystem`
      Overrides:
        `defaultConstructor` in class `polyglot.types.TypeSystem_c`

    - #### labelTypeCheckUtil

          public LabelTypeCheckUtil labelTypeCheckUtil()

      Specified by:
        `labelTypeCheckUtil` in interface `JifTypeSystem`

    - #### promoteToFatal

          public boolean promoteToFatal(polyglot.types.Type t)

      Description copied from interface: `JifTypeSystem`
      Should this exception be promoted to a fatal error?
      Specified by:
        `promoteToFatal` in interface `JifTypeSystem`

    - #### toLabel

          public Label toLabel(Principal p)

      Specified by:
        `toLabel` in interface `JifTypeSystem`
      Returns:
        the label {⊤→⊤;p←p}, representing the authority of the given principal. This can then be used to check whether L actsfor p by checking whether L <= p.

    - #### exprToAccessPath

          public AccessPath exprToAccessPath(polyglot.ast.Expr e,
                                             JifContext context)
                                      throws polyglot.types.SemanticException

      Description copied from interface: `JifTypeSystem`
      Create an AccessPath for the expression `e` in context `context`.
      Specified by:
        `exprToAccessPath` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### exprToAccessPath

          public AccessPath exprToAccessPath(polyglot.ast.Expr e,
                                             polyglot.types.Type expectedType,
                                             JifContext context)
                                      throws polyglot.types.SemanticException

      Description copied from interface: `JifTypeSystem`
      Create an AccessPath for the expression `e` with expected type `expectedType` in context `context`.
      Specified by:
        `exprToAccessPath` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### accessPathDescrip

          public java.lang.String accessPathDescrip(AccessPath path,
                                                    java.lang.String kind)

      Specified by:
        `accessPathDescrip` in interface `JifTypeSystem`

    - #### exprToPrincipal

          public Principal exprToPrincipal(JifTypeSystem ts,
                                           polyglot.ast.Expr e,
                                           JifContext context)
                                    throws polyglot.types.SemanticException

      Specified by:
        `exprToPrincipal` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### exprToLabel

          public Label exprToLabel(JifTypeSystem ts,
                                   polyglot.ast.Expr e,
                                   JifContext context)
                            throws polyglot.types.SemanticException

      Specified by:
        `exprToLabel` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### isFinalAccessExpr

          public boolean isFinalAccessExpr(polyglot.ast.Expr e)

      Specified by:
        `isFinalAccessExpr` in interface `JifTypeSystem`

    - #### isFinalAccessExprOrConst

          public boolean isFinalAccessExprOrConst(polyglot.ast.Expr e,
                                                  polyglot.types.Type expectedType)

      Specified by:
        `isFinalAccessExprOrConst` in interface `JifTypeSystem`

    - #### isFinalAccessExprOrConst

          public boolean isFinalAccessExprOrConst(polyglot.ast.Expr e)

      Specified by:
        `isFinalAccessExprOrConst` in interface `JifTypeSystem`

    - #### processFAP

          public void processFAP(polyglot.types.VarInstance fi,
                                 AccessPath path,
                                 JifContext A)
                          throws polyglot.types.SemanticException

      Specified by:
        `processFAP` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### processFAP

          protected void processFAP(polyglot.types.VarInstance fi,
                                    AccessPath path,
                                    JifContext A,
                                    java.util.Set<polyglot.types.ClassType> visited)
                             throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### processFAP

          public void processFAP(polyglot.types.ReferenceType rt,
                                 AccessPath path,
                                 JifContext A)
                          throws polyglot.types.SemanticException

      Specified by:
        `processFAP` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### processFAP

          protected void processFAP(polyglot.types.ReferenceType rt,
                                    AccessPath path,
                                    JifContext A,
                                    java.util.Set<polyglot.types.ClassType> visited)
                             throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### varInstanceToAccessPath

          public AccessPath varInstanceToAccessPath(polyglot.types.VarInstance vi,
                                                    java.lang.String name,
                                                    polyglot.util.Position pos)
                                             throws polyglot.types.SemanticException

      Specified by:
        `varInstanceToAccessPath` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### varInstanceToAccessPath

          public AccessPath varInstanceToAccessPath(polyglot.types.VarInstance vi,
                                                    polyglot.util.Position pos)
                                             throws polyglot.types.SemanticException

      Specified by:
        `varInstanceToAccessPath` in interface `JifTypeSystem`
      Throws:
        `polyglot.types.SemanticException`

    - #### needsDynamicTypeMethods

          public boolean needsDynamicTypeMethods(polyglot.types.Type ct)

      Description copied from interface: `JifTypeSystem`
      Returns true if the class has runtime methods for cast and instanceof
      Specified by:
        `needsDynamicTypeMethods` in interface `JifTypeSystem`

    - #### needsImplClass

          public boolean needsImplClass(polyglot.types.Type jpt)

      Description copied from interface: `JifTypeSystem`
      Returns true if the class has runtime methods for cast and instanceof
      Specified by:
        `needsImplClass` in interface `JifTypeSystem`

    - #### accessPathField

          protected AccessPathField accessPathField(AccessPath path,
                                                    polyglot.types.FieldInstance fi,
                                                    java.lang.String fieldName,
                                                    polyglot.util.Position pos)

      Factory method for constructing AccessPathField objects.