Packages

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): Result

    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.

    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[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  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[java.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
  28. def getContext: Analyzer.Context
  29. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  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 WildcardTypes. 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 instBounds(tvar: Global.TypeVar): Global.TypeBounds
  40. def instantiateTypeVar(tvar: Global.TypeVar): Unit
  41. 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.

  42. 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)

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

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

  48. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  49. def isInstantiatable(tvars: List[Global.TypeVar]): Boolean
  50. 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)?

  51. def isStrictlyMoreSpecific(ftpe1: Global.Type, ftpe2: Global.Type, sym1: Global.Symbol, sym2: Global.Symbol): Boolean
  52. def isUncheckable(P0: Global.Type): Boolean
    Definition Classes
    InferCheckable
  53. def isWeaklyCompatible(tp: Global.Type, pt: Global.Type): Boolean
  54. def makeFullyDefined(tp: Global.Type): Global.Type

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

  55. def methTypeArgs(fn: Global.Tree, tparams: List[Global.Symbol], formals: List[Global.Type], restpe: Global.Type, argtpes: List[Global.Type], pt: Global.Type): Result

    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
  56. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  57. final def notify(): Unit
    Definition Classes
    AnyRef
  58. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  59. 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.

  60. def setError[T <: Global.Tree](tree: T): T
  61. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  62. def toString(): String
    Definition Classes
    AnyRef → Any
  63. 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.

  64. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  65. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  66. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  67. 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
  68. object AdjustedTypeArgs

    [Martin] Can someone comment this please? I have no idea what it's for and the code is not exactly readable.

  69. object approximateAbstracts extends Global.TypeMap
  70. object toOrigin extends Global.TypeMap

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