Scala Compiler2.12.11 < Back
 

# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package tools
  Definition Classes
    scala
-  package nsc
  Definition Classes
    tools
-  package typechecker
  Definition Classes
    nsc
-  trait Infer extends Checkable

  This trait contains methods related to type parameter inference.

  This trait contains methods related to type parameter inference.

  Definition Classes
    typechecker
  Version

    1.0

- AdjustedTypeArgs
- InferCheckable
- Inferencer
- NoInstance
- approximateAbstracts
- instantiate
- toOrigin

c

scala.tools.nsc.typechecker.Infer

# Inferencer 

###

#### abstract class Inferencer extends Analyzer.InferencerContextErrors with Analyzer.InferCheckable

The context-dependent inferencer part

Source
  Infer.scala

Linear Supertypes
Analyzer.InferCheckable, Analyzer.InferencerContextErrors, AnyRef, Any
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. Inferencer
2. InferCheckable
3. InferencerContextErrors
4. AnyRef
5. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new Inferencer()

### Abstract Value Members

1.  abstract def context: Analyzer.Context

### Concrete Value Members

1.  object InferErrorGen
   Definition Classes
     InferencerContextErrors
2.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
3.  final def ##(): Int
   Definition Classes
     AnyRef → Any
4.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from Analyzer.Inferencer to any2stringadd[Analyzer.Inferencer] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
5.  def ->[B](y: B): (Analyzer.Inferencer, B)
   Implicit
     This member is added by an implicit conversion from Analyzer.Inferencer to ArrowAssoc[Analyzer.Inferencer] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
6.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
7.  def adjustTypeArgs(tparams: List[Global.Symbol], tvars: List[Global.TypeVar], targs: List[Global.Type], restpe: Global.Type = WildcardType): Analyzer.AdjustedTypeArgs

   Retract arguments that were inferred to Nothing because inference failed.

   Retract arguments that were inferred to Nothing because inference failed. Correct types for repeated params.

   We detect Nothing-due-to-failure by only retracting a parameter if either:

   - it occurs in an invariant/contravariant position in `restpe`
   - `restpe == WildcardType`

   Retracted parameters are mapped to None. TODO:

   - make sure the performance hit of storing these in a map is acceptable (it's going to be a small map in 90% of the cases, I think)
   - refactor further up the callstack so that we don't have to do this post-factum adjustment?

   Rewrite for repeated param types: Map T* entries to Seq[T].

   returns

     map from tparams to inferred arg, if inference was successful, tparams that map to None are considered left undetermined type parameters that are inferred as `scala.Nothing` and that are not covariant in `restpe` are taken to be undetermined

8.  final def asInstanceOf[T0]: T0
   Definition Classes
     Any
9.  def checkAccessible(tree: Global.Tree, sym: Global.Symbol, pre: Global.Type, site: Global.Tree): Global.Tree

   Check that `sym` is defined and accessible as a member of tree `site` with type `pre` in current context.

10.  def checkBounds(tree: Global.Tree, pre: Global.Type, owner: Global.Symbol, tparams: List[Global.Symbol], targs: List[Global.Type], prefix: String): Boolean

    error if arguments not within bounds.

11.  def checkCheckable(tree: Global.Tree, P0: Global.Type, X0: Global.Type, inPattern: Boolean, canRemedy: Boolean = false): Unit

    TODO: much better error positions.

    TODO: much better error positions. Kind of stuck right now because they just pass us the one tree. TODO: Eliminate inPattern, canRemedy, which have no place here.

    Instead of the canRemedy flag, annotate uncheckable types that have become checkable because of the availability of a class tag?

    Definition Classes
      InferCheckable
12.  def checkKindBounds(tparams: List[Global.Symbol], targs: List[Global.Type], pre: Global.Type, owner: Global.Symbol): List[String]
13.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
14.  def eligibleForTupleConversion(formals: List[Global.Type], argsCount: Int): Boolean
15.  def eligibleForTupleConversion(paramsCount: Int, argsCount: Int, varargsTarget: Boolean): Boolean

    True if the given parameter list can accept a tupled argument list, and the argument list can be tupled (based on its length.)

16.  def ensureFullyDefined(tp: Global.Type): Global.Type
17.  def ensuring(cond: (Analyzer.Inferencer) ⇒ Boolean, msg: ⇒ Any): Analyzer.Inferencer
    Implicit
      This member is added by an implicit conversion from Analyzer.Inferencer to Ensuring[Analyzer.Inferencer] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
18.  def ensuring(cond: (Analyzer.Inferencer) ⇒ Boolean): Analyzer.Inferencer
    Implicit
      This member is added by an implicit conversion from Analyzer.Inferencer to Ensuring[Analyzer.Inferencer] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
19.  def ensuring(cond: Boolean, msg: ⇒ Any): Analyzer.Inferencer
    Implicit
      This member is added by an implicit conversion from Analyzer.Inferencer to Ensuring[Analyzer.Inferencer] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
20.  def ensuring(cond: Boolean): Analyzer.Inferencer
    Implicit
      This member is added by an implicit conversion from Analyzer.Inferencer to Ensuring[Analyzer.Inferencer] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
21.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
22.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
23.  def explainTypes(tp1: Global.Type, tp2: Global.Type): Unit
24.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
25.  def formatted(fmtstr: String): String
    Implicit
      This member is added by an implicit conversion from Analyzer.Inferencer to StringFormat[Analyzer.Inferencer] performed by method StringFormat in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @inline()
26.  def freeTypeParamsOfTerms(tp: Global.Type): List[Global.Symbol]

    Collects type parameters referred to in a type.

27.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
28.  def getContext: Analyzer.Context
29.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
30.  def inferArgumentInstance(tree: Global.Tree, undetparams: List[Global.Symbol], strictPt: Global.Type, lenientPt: Global.Type): Unit

    Substitute free type variables `undetparams` of polymorphic argument expression `tree`, given two prototypes `strictPt`, and `lenientPt`.

    Substitute free type variables `undetparams` of polymorphic argument expression `tree`, given two prototypes `strictPt`, and `lenientPt`. `strictPt` is the first attempt prototype where type parameters are left unchanged. `lenientPt` is the fall-back prototype where type parameters are replaced by `WildcardType`s. We try to instantiate first to `strictPt` and then, if this fails, to `lenientPt`. If both attempts fail, an error is produced.

31.  def inferConstructorInstance(tree: Global.Tree, undetparams: List[Global.Symbol], pt0: Global.Type): Unit

    Substitute free type variables `undetparams` of type constructor `tree` in pattern, given prototype `pt`.

    Substitute free type variables `undetparams` of type constructor `tree` in pattern, given prototype `pt`.

    tree

      the constructor that needs to be instantiated

    undetparams

      the undetermined type parameters

    pt0

      the expected result type of the instance

32.  def inferExprAlternative(tree: Global.Tree, pt: Global.Type): Global.Tree

    Assign `tree` the symbol and type of the alternative which matches prototype `pt`, if it exists.

    Assign `tree` the symbol and type of the alternative which matches prototype `pt`, if it exists. If several alternatives match `pt`, take parameterless one. If no alternative matches `pt`, take the parameterless one anyway.

33.  def inferExprInstance(tree: Global.Tree, tparams: List[Global.Symbol], pt: Global.Type = WildcardType, treeTp0: Global.Type = null, keepNothings: Boolean = true, useWeaklyCompatible: Boolean = false): List[Global.Symbol]

    Infer type arguments `targs` for `tparams` of polymorphic expression in `tree`, given prototype `pt`.

    Infer type arguments `targs` for `tparams` of polymorphic expression in `tree`, given prototype `pt`.

    Substitute `tparams` to `targs` in `tree`, after adjustment by `adjustTypeArgs`, returning the type parameters that were not determined If passed, infers against specified type `treeTp` instead of `tree.tp`.

34.  def inferMethodAlternative(tree: Global.Tree, undetparams: List[Global.Symbol], argtpes0: List[Global.Type], pt0: Global.Type): Unit

    Assign `tree` the type of an alternative which is applicable to `argtpes`, and whose result type is compatible with `pt`.

    Assign `tree` the type of an alternative which is applicable to `argtpes`, and whose result type is compatible with `pt`. If several applicable alternatives exist, drop the alternatives which use default arguments, then select the most specialized one. If no applicable alternative exists, and pt != WildcardType, try again with pt = WildcardType. Otherwise, if there is no best alternative, error.

    argtpes0

      contains the argument types. If an argument is named, as "a = 3", the corresponding type is `NamedType("a", Int)`. If the name of some NamedType does not exist in an alternative's parameter names, the type is replaces by `Unit`, i.e. the argument is treated as an assignment expression.

35.  def inferMethodInstance(fn: Global.Tree, undetParams: List[Global.Symbol], args: List[Global.Tree], pt0: Global.Type): List[Global.Symbol]

    Substitute free type variables `undetparams` of application `fn(args)`, given prototype `pt`.

    Substitute free type variables `undetparams` of application `fn(args)`, given prototype `pt`.

    fn

      fn: the function that needs to be instantiated.

    undetParams

      the parameters that need to be determined

    args

      the actual arguments supplied in the call.

    pt0

      the expected type of the function application

    returns

      The type parameters that remain uninstantiated, and that thus have not been substituted.

36.  def inferModulePattern(pat: Global.Tree, pt: Global.Type): Unit
37.  def inferPolyAlternatives(tree: Global.Tree, argtypes: List[Global.Type]): Unit

    Assign `tree` the type of all polymorphic alternatives which have the same number of type parameters as does `argtypes` with all argtypes are within the corresponding type parameter bounds.

    Assign `tree` the type of all polymorphic alternatives which have the same number of type parameters as does `argtypes` with all argtypes are within the corresponding type parameter bounds. If no such polymorphic alternative exist, error.

38.  def inferTypedPattern(tree0: Global.Tree, pattp: Global.Type, pt0: Global.Type, canRemedy: Boolean): Global.Type
39.  def intersect(tp1: Global.Type, tp2: Global.Type): Global.Type

    Type intersection of simple type tp1 with general type tp2.

    Type intersection of simple type tp1 with general type tp2. The result eliminates some redundancies.

40.  def isAsSpecific(ftpe1: Global.Type, ftpe2: Global.Type): Boolean

    Is type `ftpe1` strictly more specific than type `ftpe2` when both are alternatives in an overloaded function?

    Is type `ftpe1` strictly more specific than type `ftpe2` when both are alternatives in an overloaded function?

    See also

      SLS (sec:overloading-resolution)

41.  def isCheckable(P0: Global.Type): Boolean
    Definition Classes
      InferCheckable
42.  def isCoercible(tp: Global.Type, pt: Global.Type): Boolean
43.  def isCompatibleArgs(tps: List[Global.Type], pts: List[Global.Type]): Boolean
44.  def isConservativelyCompatible(tp: Global.Type, pt: Global.Type): Boolean
45.  def isInProperSubClassOrObject(sym1: Global.Symbol, sym2: Global.Symbol): Boolean

    is symbol `sym1` defined in a proper subclass of symbol `sym2`?

46.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
47.  def isProperSubClassOrObject(sym1: Global.Symbol, sym2: Global.Symbol): Boolean

    Is sym1 (or its companion class in case it is a module) a subclass of sym2 (or its companion class in case it is a module)?

48.  def isStrictlyMoreSpecific(ftpe1: Global.Type, ftpe2: Global.Type, sym1: Global.Symbol, sym2: Global.Symbol): Boolean
49.  def isUncheckable(P0: Global.Type): Boolean
    Definition Classes
      InferCheckable
50.  def isWeaklyCompatible(tp: Global.Type, pt: Global.Type): Boolean
51.  def makeFullyDefined(tp: Global.Type): Global.Type

    Replace any (possibly bounded) wildcard types in type `tp` by existentially bound variables.

52.  def methTypeArgs(fn: Global.Tree, tparams: List[Global.Symbol], formals: List[Global.Type], restpe: Global.Type, argtpes: List[Global.Type], pt: Global.Type): Analyzer.AdjustedTypeArgs

    Return inferred type arguments, given type parameters, formal parameters, argument types, result type and expected result type.

    Return inferred type arguments, given type parameters, formal parameters, argument types, result type and expected result type. If this is not possible, throw a `NoInstance` exception. Undetermined type arguments are represented by `definitions.NothingTpe`. No check that inferred parameters conform to their bounds is made here.

    fn

      the function for reporting, may be empty

    tparams

      the type parameters of the method

    formals

      the value parameter types of the method

    restpe

      the result type of the method

    argtpes

      the argument types of the application

    pt

      the expected return type of the application

    returns

      @see adjustTypeArgs

    Exceptions thrown
53.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
54.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
55.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
56.  def protoTypeArgs(tparams: List[Global.Symbol], formals: List[Global.Type], restpe: Global.Type, pt: Global.Type): List[Global.Type]

    Return inferred proto-type arguments of function, given its type and value parameters and result type, and a prototype `pt` for the function result.

    Return inferred proto-type arguments of function, given its type and value parameters and result type, and a prototype `pt` for the function result. Type arguments need to be either determined precisely by the prototype, or they are maximized, if they occur only covariantly in the value parameter list. If instantiation of a type parameter fails, take WildcardType for the proto-type argument.

57.  def setError[T <: Global.Tree](tree: T): T
58.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
59.  def toString(): String
    Definition Classes
      AnyRef → Any
60.  def tupleIfNecessary(formals: List[Global.Type], argtpes: List[Global.Type]): List[Global.Type]

    If the argument list needs to be tupled for the parameter list, a list containing the type of the tuple.

    If the argument list needs to be tupled for the parameter list, a list containing the type of the tuple. Otherwise, the original argument list.

61.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
62.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
63.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
64.  def →[B](y: B): (Analyzer.Inferencer, B)
    Implicit
      This member is added by an implicit conversion from Analyzer.Inferencer to ArrowAssoc[Analyzer.Inferencer] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
      ArrowAssoc

### Inherited from Analyzer.InferCheckable

### Inherited from Analyzer.InferencerContextErrors

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from Analyzer.Inferencer to any2stringadd[Analyzer.Inferencer]

### Inherited by implicit conversion StringFormat from Analyzer.Inferencer to StringFormat[Analyzer.Inferencer]

### Inherited by implicit conversion Ensuring from Analyzer.Inferencer to Ensuring[Analyzer.Inferencer]

### Inherited by implicit conversion ArrowAssoc from Analyzer.Inferencer to ArrowAssoc[Analyzer.Inferencer]

### Ungrouped