Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## jif.types
Class JifTypeSystem_c

    java.lang.Object
      polyglot.types.TypeSystem_c
          polyglot.ext.param.types.ParamTypeSystem_c
              jif.types.JifTypeSystem_c

All Implemented Interfaces:
  JifTypeSystem, polyglot.ext.param.types.ParamTypeSystem, polyglot.types.TypeSystem

    public class JifTypeSystem_c

extends polyglot.ext.param.types.ParamTypeSystem_c
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`

Field Summary
`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.types.TypeSystem_c
`ABSTRACT_METHOD_FLAGS, ACCESS_FLAGS, BOOLEAN_, BYTE_, CHAR_, CLASS_, CONSTRUCTOR_FLAGS, DOUBLE_, extInfo, FIELD_FLAGS, flagsForName, FLOAT_, INITIALIZER_FLAGS, INT_, INTERFACE_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
`JifTypeSystem_c(polyglot.types.TypeSystem jlts)`

Method Summary
`java.util.List` | `abstractSuperInterfaces(polyglot.types.ReferenceType rt)` Exposes utility method of TypeSystem_c
`ActsForConstraint` | `actsForConstraint(polyglot.util.Position pos, Principal actor, Principal granter, boolean isEquiv)` Construct an acts-for constraint.
`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 principals)` Construct an authority constraint.
`AutoEndorseConstraint` | `autoEndorseConstraint(polyglot.util.Position pos, Label endorseTo)` Construct an autoendorse constraint.
`polyglot.types.Resolver` | `bodyContextResolver(polyglot.types.ClassType type, polyglot.types.Resolver outer)`
`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 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 t, java.util.List args)`
`polyglot.types.Resolver` | `classContextResolver(polyglot.types.ClassType type)`
`ConfPolicy` | `confProjection(Label L)`
`Principal` | `conjunctivePrincipal(polyglot.util.Position pos, java.util.Collection ps)`
`Principal` | `conjunctivePrincipal(polyglot.util.Position pos, Principal l, Principal r)`
`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 formalTypes, java.util.List excTypes)`
`CovariantParamLabel` | `covariantLabel(polyglot.util.Position pos, ParamInstance pi)`
`polyglot.types.ParsedClassType` | `createClassType(polyglot.types.LazyClassInitializer init, polyglot.frontend.Source fromSource)`
`polyglot.types.Context` | `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` | `defaultPackageImports()`
`DefaultSignature` | `defaultSignature()`
`boolean` | `descendsFrom(polyglot.types.Type child, polyglot.types.Type ancestor)`
`Principal` | `disjunctivePrincipal(polyglot.util.Position pos, java.util.Collection ps)`
`Principal` | `disjunctivePrincipal(polyglot.util.Position pos, Principal l, Principal r)`
`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)`
`ExternalPrincipal` | `externalPrincipal(polyglot.util.Position pos, java.lang.String name)`
`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)`
`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` | `isImplicitCastValid(polyglot.types.Type fromType, polyglot.types.Type toType)`
`boolean` | `isJifClass(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` | `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` | `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 formalTypes, java.util.List formalArgLabels, java.util.List excTypes, java.util.List 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 formalTypes, java.util.List formalArgLabels, Label endLabel, boolean isDefaultEndLabel, java.util.List excTypes, java.util.List 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 components)`
`IntegPolicy` | `joinIntegPolicy(polyglot.util.Position pos, java.util.Set components)`
`Label` | `joinLabel(polyglot.util.Position pos, java.util.Set components)`
`LabelToJavaExpr` | `joinLabelTranslator()`
`polyglot.types.PrimitiveType` | `Label()` Returns 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.
`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()`
`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 `env`.
`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 components)`
`IntegPolicy` | `meetIntegPolicy(polyglot.util.Position pos, java.util.Set components)`
`Label` | `meetLabel(polyglot.util.Position pos, java.util.Set 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 formalTypes, java.util.List excTypes)`
`polyglot.ext.param.types.MuPClass` | `mutablePClass(polyglot.util.Position pos)`
`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 pc)`
`boolean` | `numericConversionValid(polyglot.types.Type t, java.lang.Object value)`
`polyglot.types.Package` | `packageForName(polyglot.types.Package prefix, java.lang.String name)`
`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)`
`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.
`PrincipalInstance` | `principalInstance(polyglot.util.Position pos, ExternalPrincipal principal)` Constructs a principal instance for an external principal.
`ParamPrincipal` | `principalParam(polyglot.util.Position pos, ParamInstance pi)`
`ReaderPolicy` | `readerPolicy(polyglot.util.Position pos, Principal owner, java.util.Collection readers)`
`ReaderPolicy` | `readerPolicy(polyglot.util.Position pos, Principal owner, Principal reader)`
`polyglot.types.Type` | `staticTarget(polyglot.types.Type t)`
`protected polyglot.types.Type` | `strip(polyglot.types.Type type)`
`polyglot.ext.param.types.Subst` | `subst(java.util.Map substMap, java.util.Map cache)`
`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)`
`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` | `uncheckedExceptions()`
`polyglot.types.ClassType` | `uncheckedInstantiate(polyglot.util.Position pos, polyglot.ext.param.types.PClass t, java.util.List 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.
`WriterPolicy` | `writerPolicy(polyglot.util.Position pos, Principal owner, java.util.Collection 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_, Boolean, Byte, callValid, canOverride, Char, checkAccessFlags, checkClassConformance, checkConstructorFlags, checkCycles, checkCycles, checkFieldFlags, checkInitializerFlags, checkLocalClassFlags, checkLocalFlags, checkMemberClassFlags, checkMethodFlags, checkOverride, checkTopLevelClassFlags, Class, classAccessible, classAccessible, classAccessibleFromPackage, ClassCastException, classContextResolver, classFileLazyClassInitializer, Cloneable, createArrayType, createClassContextResolver, createClassType, createClassType, createClassType, createNewFlag, createNull, createPackage, createPackage, createPackageContextResolver, createPrimitive, deserializedClassInitializer, Double, Error, Exception, extensionInfo, Final, findAcceptableConstructors, findAcceptableMethods, findConstructor, findConstructor, findField, findField, findField, findFields, findImplementingMethod, findMemberClass, findMemberClass, findMemberClass, findMethod, findMethod, findMostSpecificProcedures, findProcedure, flagsForBits, flagsForName, Float, forName, getTransformedClassName, getTypeEncoderRootSet, hasEnclosingInstance, hasFormals, hasMethod, hasMethodNamed, implemented, importTable, importTable, initEnums, initFlags, initTypes, Int, Interface, interfaces, isAccessible, isCanonical, isEnclosed, isSameMethod, isThrowable, isUncheckedException, legalAbstractMethodFlags, legalAccessFlags, legalConstructorFlags, legalFieldFlags, legalInitializerFlags, legalInterfaceFlags, legalLocalClassFlags, legalLocalFlags, legalMemberClassFlags, legalMethodFlags, legalTopLevelClassFlags, listToString, load, loadedResolver, Long, methodCallValid, moreSpecific, Native, NoFlags, Null, NullPointerException, numericConversionValid, Object, OutOfBoundsException, overrides, packageContextResolver, packageContextResolver, packageContextResolver, packageEquals, packageExists, packageForName, parsedResolver, placeHolder, placeHolder, Private, promote, promote, promoteNumeric, promoteNumeric, Protected, Public, restoreSystemResolver, RuntimeException, saveSystemResolver, Serializable, Short, Static, StrictFP, String, superType, Synchronized, systemResolver, Throwable, throwsSubset, toString, Transient, translateArray, translatePackage, 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, Boolean, Byte, callValid, canOverride, Char, checkAccessFlags, checkClassConformance, checkConstructorFlags, checkCycles, checkFieldFlags, checkInitializerFlags, checkLocalClassFlags, checkLocalFlags, checkMemberClassFlags, checkMethodFlags, checkOverride, checkTopLevelClassFlags, Class, classAccessible, classAccessible, classAccessibleFromPackage, ClassCastException, classContextResolver, classFileLazyClassInitializer, Cloneable, createClassContextResolver, createClassType, createClassType, createClassType, createNewFlag, createPackage, createPackage, createPackageContextResolver, deserializedClassInitializer, Double, Error, Exception, extensionInfo, Final, findConstructor, findConstructor, findField, findField, findField, findImplementingMethod, findMemberClass, findMemberClass, findMemberClass, findMethod, findMethod, flagsForBits, Float, forName, getTransformedClassName, getTypeEncoderRootSet, hasEnclosingInstance, hasFormals, hasMethod, hasMethodNamed, implemented, importTable, importTable, Int, Interface, interfaces, isAccessible, isCanonical, isEnclosed, isSameMethod, isThrowable, isUncheckedException, legalAbstractMethodFlags, legalAccessFlags, legalConstructorFlags, legalFieldFlags, legalInitializerFlags, legalInterfaceFlags, legalLocalClassFlags, legalLocalFlags, legalMemberClassFlags, legalMethodFlags, legalTopLevelClassFlags, loadedResolver, Long, methodCallValid, moreSpecific, Native, NoFlags, Null, NullPointerException, numericConversionValid, Object, OutOfBoundsException, overrides, packageContextResolver, packageContextResolver, packageContextResolver, packageEquals, packageExists, 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

### 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 mutablePClass(polyglot.util.Position pos)

  Specified by:
    `mutablePClass` in interface `polyglot.ext.param.types.ParamTypeSystem`
  Overrides:
    `mutablePClass` in class `polyglot.ext.param.types.ParamTypeSystem_c`

### 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`

### packageForName

    public polyglot.types.Package packageForName(polyglot.types.Package prefix,
                                                 java.lang.String name)
                                          throws polyglot.types.SemanticException

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

### 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 polyglot.types.Context createContext()

  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 formalTypes,
                                                                  java.util.List 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 formalTypes,
                                                         java.util.List formalArgLabels,
                                                         java.util.List excTypes,
                                                         java.util.List 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 formalTypes,
                                                        java.util.List 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 formalTypes,
                                               java.util.List formalArgLabels,
                                               Label endLabel,
                                               boolean isDefaultEndLabel,
                                               java.util.List excTypes,
                                               java.util.List 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`

### bodyContextResolver

    public polyglot.types.Resolver bodyContextResolver(polyglot.types.ClassType type,
                                                       polyglot.types.Resolver outer)

### classContextResolver

    public polyglot.types.Resolver classContextResolver(polyglot.types.ClassType type)

  Specified by:
    `classContextResolver` in interface `polyglot.types.TypeSystem`
  Overrides:
    `classContextResolver` 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 defaultPackageImports()

  Specified by:
    `defaultPackageImports` in interface `polyglot.types.TypeSystem`
  Overrides:
    `defaultPackageImports` 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 pc)

  Specified by:
    `nullInstantiate` in interface `JifTypeSystem`

### checkInstantiation

    public void checkInstantiation(polyglot.util.Position pos,
                                   polyglot.ext.param.types.PClass t,
                                   java.util.List args)
                            throws polyglot.types.SemanticException

  Overrides:
    `checkInstantiation` in class `polyglot.ext.param.types.ParamTypeSystem_c`
  Throws:
    `polyglot.types.SemanticException`

### uncheckedInstantiate

    public polyglot.types.ClassType uncheckedInstantiate(polyglot.util.Position pos,
                                                         polyglot.ext.param.types.PClass t,
                                                         java.util.List actuals)

  Overrides:
    `uncheckedInstantiate` in class `polyglot.ext.param.types.ParamTypeSystem_c`

### subst

    public polyglot.ext.param.types.Subst subst(java.util.Map substMap,
                                                java.util.Map cache)

  Specified by:
    `subst` in interface `polyglot.ext.param.types.ParamTypeSystem`
  Overrides:
    `subst` in class `polyglot.ext.param.types.ParamTypeSystem_c`

### freshLabelVariable

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

  Specified by:
    `freshLabelVariable` 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 ps)

  Specified by:
    `conjunctivePrincipal` in interface `JifTypeSystem`

### 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 ps)

  Specified by:
    `disjunctivePrincipal` in interface `JifTypeSystem`

### topLabel

    public Label topLabel(polyglot.util.Position pos)

  Specified by:
    `topLabel` in interface `JifTypeSystem`

### topLabel

    public Label topLabel()

  Specified by:
    `topLabel` in interface `JifTypeSystem`

### bottomLabel

    public Label bottomLabel(polyglot.util.Position pos)

  Specified by:
    `bottomLabel` in interface `JifTypeSystem`

### bottomLabel

    public Label bottomLabel()

  Specified by:
    `bottomLabel` in interface `JifTypeSystem`

### noComponentsLabel

    public Label noComponentsLabel()

  Specified by:
    `noComponentsLabel` in interface `JifTypeSystem`

### noComponentsLabel

    public Label noComponentsLabel(polyglot.util.Position pos)

  Specified by:
    `noComponentsLabel` in interface `JifTypeSystem`

### 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 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 writers)

  Specified by:
    `writerPolicy` in interface `JifTypeSystem`

### bottomConfPolicy

    public ConfPolicy bottomConfPolicy(polyglot.util.Position pos)

  Specified by:
    `bottomConfPolicy` in interface `JifTypeSystem`

### bottomIntegPolicy

    public IntegPolicy bottomIntegPolicy(polyglot.util.Position pos)

  Specified by:
    `bottomIntegPolicy` in interface `JifTypeSystem`

### topConfPolicy

    public ConfPolicy topConfPolicy(polyglot.util.Position pos)

  Specified by:
    `topConfPolicy` in interface `JifTypeSystem`

### topIntegPolicy

    public IntegPolicy topIntegPolicy(polyglot.util.Position pos)

  Specified by:
    `topIntegPolicy` in interface `JifTypeSystem`

### joinLabel

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

  Specified by:
    `joinLabel` in interface `JifTypeSystem`

### joinLabelTranslator

    public LabelToJavaExpr joinLabelTranslator()

### meetLabel

    public Label meetLabel(polyglot.util.Position pos,
                           java.util.Set 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 ActsForConstraint actsForConstraint(polyglot.util.Position pos,
                                               Principal actor,
                                               Principal granter,
                                               boolean isEquiv)

  Description copied from interface: `JifTypeSystem`
  Construct an acts-for constraint.

  Specified by:
    `actsForConstraint` in interface `JifTypeSystem`

### 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`

### authConstraint

    public AuthConstraint authConstraint(polyglot.util.Position pos,
                                         java.util.List 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 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`

### isJifClass

    public boolean isJifClass(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). 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:
    `isJifClass` 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 not untrusted; Java classes can be explicitly marked as not by a specially 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`

### leq

    public boolean leq(Label L1,
                       Label L2)

  Description copied from interface: `JifTypeSystem`
  Returns true iff L1 <= L2 in `env`.

  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 components)

  Specified by:
    `joinConfPolicy` in interface `JifTypeSystem`

### joinIntegPolicy

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

  Specified by:
    `joinIntegPolicy` in interface `JifTypeSystem`

### meetConfPolicy

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

  Specified by:
    `meetConfPolicy` in interface `JifTypeSystem`

### meetIntegPolicy

    public IntegPolicy meetIntegPolicy(polyglot.util.Position pos,
                                       java.util.Set 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 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 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`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD