jif.visit

## Class LabelChecker

- java.lang.Object
- - jif.visit.LabelChecker

- All Implemented Interfaces:
    java.lang.Cloneable, polyglot.util.Copy

      public class LabelChecker
      extends java.lang.Object
      implements polyglot.util.Copy

  The `LabelChecker` class is used in the label checking of Jif. Primarily it provides the method `labelCheck(Node)` which invokes the `labelCheck` method on nodes, utility functions to help in the implementation of the `labelCheck` methods, as well as references to the appropriate `Solver` and `JifContext`.

  `LabelChecker` is mostly imperative; however, the `JifContext` is treated functionally, and whenever a `LabelChecker` is given a new `JifContext`, a new `LabelChecker` is created.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface polyglot.util.Copy

      `polyglot.util.Copy.Util`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected polyglot.frontend.Job` | `job`
    `protected polyglot.ast.NodeFactory` | `nf`
    `protected boolean` | `solvePerClassBody` If true, then a new system of constraints will be used for each class body, and upon leaving the class body, the system of constraints will be solved.
    `protected boolean` | `solvePerMethod` If true, then a new system of constraints will be used for each method body, and upon leaving the method body, the system of constraints will be solved.
    `protected Solver` | `solver` The `Solver` to add constraints to.
    `protected JifTypeSystem` | `ts`
    `protected boolean` | `warningsEnabled` If true, then warnings will be produced; otherwise, warnings will be silenced.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `LabelChecker(polyglot.frontend.Job job, polyglot.types.TypeSystem ts, polyglot.ast.NodeFactory nf, boolean warningsEnabled, boolean solvePerClassBody, boolean solvePerMethod, boolean doLabelSubst)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `constrain(Constraint c)`
    `void` | `constrain(NamedLabel lhs, Constraint.Kind kind, NamedLabel rhs, LabelEnv env, polyglot.util.Position pos)`
    `void` | `constrain(NamedLabel lhs, Constraint.Kind kind, NamedLabel rhs, LabelEnv env, polyglot.util.Position pos, boolean report, ConstraintMessage msg)`
    `void` | `constrain(NamedLabel lhs, Constraint.Kind kind, NamedLabel rhs, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg)`
    `void` | `constrain(NamedLabel label, Principal p, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg)` Adds a constraint to the solver, specifying that the given label must actfor the given principal.
    `void` | `constrain(NamedLabel label, Principal p, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg, boolean report)` Adds a constraint to the solver, specifying that the given label must actfor the given principal.
    `void` | `constrain(Principal p, Constraint.Kind kind, Principal q, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg)`
    `void` | `constrain(Principal p, Constraint.Kind kind, Principal q, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg, boolean report)`
    `JifContext` | `context()`
    `LabelChecker` | `context(JifContext c)`
    `java.lang.Object` | `copy()`
    `CallHelper` | `createCallHelper(Label receiverLabel, polyglot.ast.Receiver receiver, polyglot.types.ReferenceType calleeContainer, JifProcedureInstance pi, java.util.List<polyglot.ast.Expr> actualArgs, polyglot.util.Position position)`
    `CallHelper` | `createCallHelper(Label receiverLabel, polyglot.types.ReferenceType calleeContainer, JifProcedureInstance pi, java.util.List<polyglot.ast.Expr> actualArgs, polyglot.util.Position position)`
    `CallHelper` | `createOverrideHelper(JifMethodInstance overridden, JifMethodInstance overriding)`
    `void` | `enteringClassDecl(polyglot.types.ClassType ct)` Called by JifClassDeclExt just before this label checker is used to check a class body.
    `void` | `enteringMethod(polyglot.types.MethodInstance mi)` Called by JifMethodDeclExt just before this label checker is used to check a method body.
    `polyglot.util.ErrorQueue` | `errorQueue()`
    `polyglot.ast.Node` | `finishedLabelCheckPass(polyglot.ast.Node n)` This method should be called on the top level label checker once the label checking has finished.
    `boolean` | `ignoredForSinglePathRule(Path p)` Helper function that can be overriden to indicate if a path is to be ignored for the single path rule (such as the NV path).
    `JifContext` | `jifContext()`
    `JifTypeSystem` | `jifTypeSystem()`
    `polyglot.frontend.Job` | `job()`
    `polyglot.ast.Node` | `labelCheck(polyglot.ast.Node n)`
    `protected JifLabelSubst` | `labelSubst()` Create a new JifLabelSubst.
    `JifClassDecl` | `leavingClassDecl(JifClassDecl n)` Called by JifClassDeclExt just after this label checker has been used to check a class body.
    `JifMethodDecl` | `leavingMethod(JifMethodDecl n)` Called by JifClassDeclExt just after this label checker has been used to check a method body.
    `Label` | `lowerBound(Label L1, Label L2)` Returns a lower bound for L1 and L2
    `polyglot.ast.NodeFactory` | `nodeFactory()`
    `protected polyglot.ast.Node` | `postLabelCheck(polyglot.ast.Node old, polyglot.ast.Node n)`
    `protected polyglot.ast.Node` | `preLabelCheck(polyglot.ast.Node n)`
    `void` | `reportSemanticException(polyglot.types.SemanticException e)`
    `protected polyglot.ast.Node` | `solveConstraints(polyglot.ast.Node n)`
    `Solver` | `solver()`
    `JifTypeSystem` | `typeSystem()`
    `Label` | `upperBound(Label L1, Label L2)` Returns an upper bound for L1 and L2
    `Label` | `upperBound(Label L1, Label L2, Label L3)`
    `boolean` | `warningsEnabled()`

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

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

- - ### Field Detail

    - #### ts

          protected final JifTypeSystem ts

    - #### job

          protected final polyglot.frontend.Job job

    - #### nf

          protected final polyglot.ast.NodeFactory nf

    - #### warningsEnabled

          protected final boolean warningsEnabled

      If true, then warnings will be produced; otherwise, warnings will be silenced.

    - #### solvePerClassBody

          protected final boolean solvePerClassBody

      If true, then a new system of constraints will be used for each class body, and upon leaving the class body, the system of constraints will be solved.

    - #### solvePerMethod

          protected final boolean solvePerMethod

      If true, then a new system of constraints will be used for each method body, and upon leaving the method body, the system of constraints will be solved.

    - #### solver

          protected Solver solver

      The `Solver` to add constraints to. Depending on `solveClassBodies`, a new `Solver` is used for every class, or a single `Solver` used for the entire compilation.

  - ### Constructor Detail

    - #### LabelChecker

          public LabelChecker(polyglot.frontend.Job job,
                              polyglot.types.TypeSystem ts,
                              polyglot.ast.NodeFactory nf,
                              boolean warningsEnabled,
                              boolean solvePerClassBody,
                              boolean solvePerMethod,
                              boolean doLabelSubst)

  - ### Method Detail

    - #### copy

          public java.lang.Object copy()

      Specified by:
        `copy` in interface `polyglot.util.Copy`

    - #### context

          public JifContext context()

    - #### jifContext

          public JifContext jifContext()

    - #### context

          public LabelChecker context(JifContext c)

    - #### typeSystem

          public JifTypeSystem typeSystem()

    - #### jifTypeSystem

          public JifTypeSystem jifTypeSystem()

    - #### nodeFactory

          public polyglot.ast.NodeFactory nodeFactory()

    - #### solver

          public Solver solver()

    - #### job

          public polyglot.frontend.Job job()

    - #### warningsEnabled

          public boolean warningsEnabled()

    - #### errorQueue

          public polyglot.util.ErrorQueue errorQueue()

    - #### upperBound

          public Label upperBound(Label L1,
                                  Label L2)

      Returns an upper bound for L1 and L2

    - #### upperBound

          public Label upperBound(Label L1,
                                  Label L2,
                                  Label L3)

    - #### lowerBound

          public Label lowerBound(Label L1,
                                  Label L2)

      Returns a lower bound for L1 and L2

    - #### preLabelCheck

          protected polyglot.ast.Node preLabelCheck(polyglot.ast.Node n)

    - #### postLabelCheck

          protected polyglot.ast.Node postLabelCheck(polyglot.ast.Node old,
                                                     polyglot.ast.Node n)

    - #### labelCheck

          public polyglot.ast.Node labelCheck(polyglot.ast.Node n)
                                       throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(NamedLabel lhs,
                                Constraint.Kind kind,
                                NamedLabel rhs,
                                LabelEnv env,
                                polyglot.util.Position pos,
                                ConstraintMessage msg)
                         throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(NamedLabel lhs,
                                Constraint.Kind kind,
                                NamedLabel rhs,
                                LabelEnv env,
                                polyglot.util.Position pos,
                                boolean report,
                                ConstraintMessage msg)
                         throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(NamedLabel lhs,
                                Constraint.Kind kind,
                                NamedLabel rhs,
                                LabelEnv env,
                                polyglot.util.Position pos)
                         throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          protected void constrain(Constraint c)
                            throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(Principal p,
                                Constraint.Kind kind,
                                Principal q,
                                LabelEnv env,
                                polyglot.util.Position pos,
                                ConstraintMessage msg)
                         throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(Principal p,
                                Constraint.Kind kind,
                                Principal q,
                                LabelEnv env,
                                polyglot.util.Position pos,
                                ConstraintMessage msg,
                                boolean report)
                         throws polyglot.types.SemanticException

      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(NamedLabel label,
                                Principal p,
                                LabelEnv env,
                                polyglot.util.Position pos,
                                ConstraintMessage msg)
                         throws polyglot.types.SemanticException

      Adds a constraint to the solver, specifying that the given label must actfor the given principal.
      Throws:
        `polyglot.types.SemanticException`

    - #### constrain

          public void constrain(NamedLabel label,
                                Principal p,
                                LabelEnv env,
                                polyglot.util.Position pos,
                                ConstraintMessage msg,
                                boolean report)
                         throws polyglot.types.SemanticException

      Adds a constraint to the solver, specifying that the given label must actfor the given principal.
      Throws:
        `polyglot.types.SemanticException`

    - #### enteringClassDecl

          public void enteringClassDecl(polyglot.types.ClassType ct)

      Called by JifClassDeclExt just before this label checker is used to check a class body. This allows us to use a different solver if required.

    - #### enteringMethod

          public void enteringMethod(polyglot.types.MethodInstance mi)

      Called by JifMethodDeclExt just before this label checker is used to check a method body. This allows us to use a different solver if required.

    - #### leavingClassDecl

          public JifClassDecl leavingClassDecl(JifClassDecl n)

      Called by JifClassDeclExt just after this label checker has been used to check a class body. This allows us to use a different solver if required.

    - #### leavingMethod

          public JifMethodDecl leavingMethod(JifMethodDecl n)

      Called by JifClassDeclExt just after this label checker has been used to check a method body. This allows us to use a different solver if required.

    - #### finishedLabelCheckPass

          public polyglot.ast.Node finishedLabelCheckPass(polyglot.ast.Node n)

      This method should be called on the top level label checker once the label checking has finished. This will perform label substitution if required.

    - #### labelSubst

          protected JifLabelSubst labelSubst()

      Create a new JifLabelSubst. Abstracted out so we can override what implementation we're using for it.

    - #### solveConstraints

          protected polyglot.ast.Node solveConstraints(polyglot.ast.Node n)

    - #### reportSemanticException

          public void reportSemanticException(polyglot.types.SemanticException e)

    - #### createCallHelper

          public CallHelper createCallHelper(Label receiverLabel,
                                             polyglot.ast.Receiver receiver,
                                             polyglot.types.ReferenceType calleeContainer,
                                             JifProcedureInstance pi,
                                             java.util.List<polyglot.ast.Expr> actualArgs,
                                             polyglot.util.Position position)

    - #### createCallHelper

          public CallHelper createCallHelper(Label receiverLabel,
                                             polyglot.types.ReferenceType calleeContainer,
                                             JifProcedureInstance pi,
                                             java.util.List<polyglot.ast.Expr> actualArgs,
                                             polyglot.util.Position position)

    - #### createOverrideHelper

          public CallHelper createOverrideHelper(JifMethodInstance overridden,
                                                 JifMethodInstance overriding)

    - #### ignoredForSinglePathRule

          public boolean ignoredForSinglePathRule(Path p)

      Helper function that can be overriden to indicate if a path is to be ignored for the single path rule (such as the NV path).