org.checkerframework.framework.util.typeinference.solver.TargetConstraints Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of checker Show documentation

The Checker Framework enhances Java's type system to make it more powerful and useful. This lets software developers detect and prevent errors in their Java programs. The Checker Framework includes compiler plug-ins ("checkers") that find bugs or verify their absence. It also permits you to write your own compiler plug-ins.

There is a newer version: 3.44.0

Show newest version

package org.checkerframework.framework.util.typeinference.solver;

import java.util.LinkedHashMap;
import java.util.Map;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.type.TypeVariable;
import org.checkerframework.framework.type.AnnotatedTypeMirror;
import org.checkerframework.framework.util.AnnotationMirrorMap;
import org.checkerframework.framework.util.AnnotationMirrorSet;

/**
 * TargetConstraints represents the set of all TUConstraints for which target was the type
 * parameter, i.e. the T in the TUConstraint. Unlike AF/TU Constraints, this class holds multiple
 * constraints and is mutated during solving (where the TU/AF Constraints are immutable).
 *
 * @see org.checkerframework.framework.util.typeinference.solver.ConstraintMap
 */
public class TargetConstraints {
  /**
   * The type parameter for which we are inferring a type argument. All constraints in this object
   * are related to this target.
   */
  public final TypeVariable target;

  public final Equalities equalities;

  /**
   * The target is the supertype in this case, that these are supertype constraints in which target
   * is the supertype. These are NOT supertypes of the target.
   */
  public final Supertypes supertypes;

  /**
   * The target is the supertype in this case, that these are subtype constraints in which target is
   * the subtype. These are NOT subtypes of the target.
   */
  public final Subtypes subtypes;

  public TargetConstraints(final TypeVariable target) {
    this.target = target;
    this.equalities = new Equalities();
    this.supertypes = new Supertypes();
    this.subtypes = new Subtypes();
  }

  protected static class Equalities {
    // Map( hierarchy top -> exact annotation in hierarchy)
    public AnnotationMirrorMap primaries = new AnnotationMirrorMap<>();

    // Map( type -> hierarchy top for which the primary annotation of type is equal to the
    // primary annotation of the target)
    // note all components and underlying types are EXACTLY equal to the key to this map
    public final Map types = new LinkedHashMap<>();

    // Map( type -> hierarchy top for which the primary annotation of target is equal to the
    // primary annotaiton of the target)
    // note all components and underlying types are EXACTLY equal to the key to this map
    public final Map targets = new LinkedHashMap<>();

    public void clear() {
      primaries.clear();
      types.clear();
      targets.clear();
    }
  }

  // remember these are constraint in which target is the supertype
  protected static class Supertypes {
    // Map( hierarchy top -> annotations that are subtypes to target in hierarchy)
    public AnnotationMirrorMap primaries = new AnnotationMirrorMap<>();

    // Map( type -> hierarchy tops for which the primary annotations of type are subtypes of the
    // primary annotations of the target)
    // note all components and underlying types must uphold the supertype relationship in all
    // hierarchies
    public final Map types = new LinkedHashMap<>();

    // Map( otherTarget -> hierarchy tops for which the primary annotations of otherTarget are
    // subtypes of the primary annotations of the target)
    // note all components and underlying types must uphold the subtype relationship in all
    // hierarchies
    public final Map targets = new LinkedHashMap<>();

    public void clear() {
      primaries.clear();
      types.clear();
      targets.clear();
    }
  }

  // remember these are constraint in which target is the subtype
  protected static class Subtypes {
    // Map( hierarchy top -> annotations that are supertypes to target in hierarchy)
    public AnnotationMirrorMap primaries = new AnnotationMirrorMap<>();

    // Map( type -> hierarchy tops for which the primary annotations of type are supertypes of
    // the primary annotations of the target)
    // note all components and underlying types must uphold the supertype relationship in all
    // hierarchies
    public final Map types = new LinkedHashMap<>();

    // Map( otherTarget -> hierarchy tops for which the primary annotations of otherTarget are
    // supertypes of the primary annotations of the target)
    // note all components and underlying types must uphold the subtype relationship in all
    // hierarchies
    public final Map targets = new LinkedHashMap<>();

    public void clear() {
      primaries.clear();
      types.clear();
      targets.clear();
    }
  }
}