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.ext.jl.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.ext.jl.types.TypeSystem_c
`polyglot.ext.jl.types.TypeSystem_c.MostSpecificComparator`

Field Summary
`protected polyglot.types.PrimitiveType` | `LABEL_`
`protected polyglot.types.PrimitiveType` | `PRINCIPAL_`
`protected polyglot.types.Type` | `PRINCIPAL_CLASS_`

Fields inherited from class polyglot.ext.jl.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.VarInstance vi)`
`AuthConstraint` | `authConstraint(polyglot.util.Position pos, java.util.List principals)` Construct an authority constraint.
`polyglot.types.Resolver` | `bodyContextResolver(polyglot.types.ClassType type, polyglot.types.Resolver outer)`
`Label` | `bottomLabel()`
`Label` | `bottomLabel(polyglot.util.Position pos)`
`CallerConstraint` | `callerConstraint(polyglot.util.Position pos, java.util.List principals)` Construct a caller constraint.
`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)`
`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()`
`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)`
`DynamicLabel` | `dynamicLabel(polyglot.util.Position pos, AccessPath path)`
`DynamicPrincipal` | `dynamicPrincipal(polyglot.util.Position pos, AccessPath path)`
`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
`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)`
`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` | `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)`
`Label` | `join(Label L1, Label L2)` Returns the join of L1 and L2.
`Label` | `joinLabel(polyglot.util.Position pos, java.util.Collection components)`
`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.
`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)`
`boolean` | `leq(Label L1, Label L2, LabelEnv env)` Returns true iff L1 <= L2 in `ph`.
`polyglot.types.LocalInstance` | `localInstance(polyglot.util.Position pos, polyglot.types.Flags flags, polyglot.types.Type type, java.lang.String name)`
`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` | `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)`
`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)`
`PolicyLabel` | `policyLabel(polyglot.util.Position pos, Principal owner, java.util.Collection readers)`
`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)`
`Label` | `runtimeLabel()`
`Label` | `runtimeLabel(polyglot.util.Position pos)`
`Solver` | `solver(java.lang.String solverName)` Returns a new label constraint system solver.
`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(JifClassType ct)`
`ThisLabel` | `thisLabel(polyglot.util.Position pos, JifClassType ct)`
`Label` | `topLabel()`
`Label` | `topLabel(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.

Methods inherited from class polyglot.ext.param.types.ParamTypeSystem_c
`instantiate, subst, subst`

Methods inherited from class polyglot.ext.jl.types.TypeSystem_c
`Abstract, accessibleFromPackage, ArithmeticException, arrayOf, arrayOf, arrayOf, arrayOf, ArrayStoreException, arrayType, 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, Cloneable, 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, 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

### PRINCIPAL_

    protected polyglot.types.PrimitiveType PRINCIPAL_

### LABEL_

    protected polyglot.types.PrimitiveType LABEL_

### PRINCIPAL_CLASS_

    protected polyglot.types.Type PRINCIPAL_CLASS_

Constructor Detail

### JifTypeSystem_c

    public JifTypeSystem_c(polyglot.types.TypeSystem jlts)

Method Detail

### solver

    public Solver solver(java.lang.String solverName)

  Description copied from interface: `JifTypeSystem`
  Returns a new label constraint system solver.

  Specified by:
    `solver` 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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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)

### 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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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`
  Returns:

### 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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.types.TypeSystem_c`

### defaultPackageImports

    public java.util.List defaultPackageImports()

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

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

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

### notTaken

    public Label notTaken(polyglot.util.Position pos)

  Specified by:
    `notTaken` in interface `JifTypeSystem`

### notTaken

    public Label notTaken()

  Specified by:
    `notTaken` in interface `JifTypeSystem`

### runtimeLabel

    public Label runtimeLabel(polyglot.util.Position pos)

  Specified by:
    `runtimeLabel` in interface `JifTypeSystem`

### runtimeLabel

    public Label runtimeLabel()

  Specified by:
    `runtimeLabel` 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`

### policyLabel

    public PolicyLabel policyLabel(polyglot.util.Position pos,
                                   Principal owner,
                                   java.util.Collection readers)

  Specified by:
    `policyLabel` in interface `JifTypeSystem`

### joinLabel

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

  Specified by:
    `joinLabel` in interface `JifTypeSystem`

### dynamicLabel

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

  Specified by:
    `dynamicLabel` in interface `JifTypeSystem`

### argLabel

    public ArgLabel argLabel(polyglot.util.Position pos,
                             polyglot.types.VarInstance vi)

  Specified by:
    `argLabel` in interface `JifTypeSystem`

### thisLabel

    public ThisLabel thisLabel(JifClassType ct)

  Specified by:
    `thisLabel` in interface `JifTypeSystem`

### thisLabel

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

  Specified by:
    `thisLabel` in interface `JifTypeSystem`

### unknownLabel

    public UnknownLabel unknownLabel(polyglot.util.Position pos)

  Specified by:
    `unknownLabel` 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`

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

### 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.ext.jl.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`

### leq

    public boolean leq(Label L1,
                       Label L2,
                       LabelEnv env)

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

  Specified by:
    `leq` in interface `JifTypeSystem`

### leq

    public boolean leq(Label L1,
                       Label L2)

  Specified by:
    `leq` 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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.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.ext.jl.types.TypeSystem_c`

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