jif.types.label

## Class AccessPathLocal

- java.lang.Object
- - jif.types.label.AccessPath
  - - jif.types.label.AccessPathRoot
    - - jif.types.label.AccessPathLocal

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

      public class AccessPathLocal
      extends AccessPathRoot

  Represents a final access path rooted at a local variable.
  See Also:
    `AccessPath`, Serialized Form

- - ### 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.types.LocalInstance` | `li`
    `protected java.lang.String` | `name`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AccessPathLocal(polyglot.types.LocalInstance li, java.lang.String name, polyglot.util.Position pos)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(java.lang.Object o)`
    `java.lang.String` | `exprString()`
    `int` | `hashCode()`
    `boolean` | `isCanonical()`
    `boolean` | `isNeverNull()`
    `PathMap` | `labelcheck(JifContext A, LabelChecker lc)`
    `polyglot.types.LocalInstance` | `localInstance()`
    `java.lang.String` | `name()`
    `AccessPathLocal` | `name(java.lang.String name)`
    `void` | `setIsNeverNull()`
    `AccessPath` | `subst(AccessPathRoot r, AccessPath e)` Return the result of substituting the root r with the access path e.
    `java.lang.String` | `toString()`
    `polyglot.types.Type` | `type()` The type of the access path (when the access path is regarded as an expression).
    `void` | `verify(JifContext A)` Go through the path, check that all the type information is set correctly, and check that every field access is to a final field, and any local used is final

    - ### Methods inherited from class jif.types.label.AccessPathRoot

      `equivalentTo, isUninterpreted, root`

    - ### Methods inherited from class jif.types.label.AccessPath

      `copy, position, throwTypes`

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

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

- - ### Field Detail

    - #### li

          protected polyglot.types.LocalInstance li

    - #### name

          protected java.lang.String name

  - ### Constructor Detail

    - #### AccessPathLocal

          public AccessPathLocal(polyglot.types.LocalInstance li,
                                 java.lang.String name,
                                 polyglot.util.Position pos)

  - ### Method Detail

    - #### isCanonical

          public boolean isCanonical()

      Specified by:
        `isCanonical` in class `AccessPath`

    - #### subst

          public AccessPath subst(AccessPathRoot r,
                                  AccessPath e)

      Description copied from class: `AccessPath`
      Return the result of substituting the root r with the access path e. For example, given a field access path "this.f", substituting the access path root "this" for the access path "o.g" will result in the access path "o.g.f". This method is used to instantiate procedures for calls, and labels of fields.
      Specified by:
        `subst` in class `AccessPath`

    - #### name

          public AccessPathLocal name(java.lang.String name)

    - #### isNeverNull

          public boolean isNeverNull()

      Specified by:
        `isNeverNull` in class `AccessPath`

    - #### setIsNeverNull

          public void setIsNeverNull()

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `java.lang.Object`

    - #### exprString

          public java.lang.String exprString()

      Overrides:
        `exprString` in class `AccessPath`

    - #### name

          public java.lang.String name()

    - #### localInstance

          public polyglot.types.LocalInstance localInstance()

    - #### equals

          public boolean equals(java.lang.Object o)

      Specified by:
        `equals` in class `AccessPath`

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in class `AccessPath`

    - #### type

          public polyglot.types.Type type()

      Description copied from class: `AccessPath`
      The type of the access path (when the access path is regarded as an expression).
      Specified by:
        `type` in class `AccessPath`

    - #### labelcheck

          public PathMap labelcheck(JifContext A,
                                    LabelChecker lc)

      Overrides:
        `labelcheck` in class `AccessPathRoot`

    - #### verify

          public void verify(JifContext A)
                      throws polyglot.types.SemanticException

      Description copied from class: `AccessPath`
      Go through the path, check that all the type information is set correctly, and check that every field access is to a final field, and any local used is final
      Overrides:
        `verify` in class `AccessPath`
      Throws:
        `polyglot.types.SemanticException`