@@ -1128,21 +1128,16 @@ object Types {
11281128 }
11291129
11301130 /** The type <this . name> , reduced if possible */
1131- def select (name : Name )(implicit ctx : Context ): Type = name match {
1132- case name : TermName => TermRef (this , name)
1133- case name : TypeName => TypeRef (this , name).reduceProjection
1134- }
1131+ def select (name : Name )(implicit ctx : Context ): Type =
1132+ NamedType (this , name).reduceProjection
11351133
11361134 /** The type <this . name> , reduced if possible, with given denotation if unreduced */
1137- def select (name : Name , denot : Denotation )(implicit ctx : Context ): Type = name match {
1138- case name : TermName => TermRef (this , name, denot)
1139- case name : TypeName => TypeRef (this , name, denot).reduceProjection
1140- }
1135+ def select (name : Name , denot : Denotation )(implicit ctx : Context ): Type =
1136+ NamedType (this , name, denot).reduceProjection
11411137
1142- /** The type <this . name> with given symbol , reduced if possible */
1138+ /** The type <this . name> with either `sym` or its signed name as designator , reduced if possible */
11431139 def select (sym : Symbol )(implicit ctx : Context ): Type =
1144- if (sym.isTerm) TermRef .withSym(this , sym.asTerm)
1145- else TypeRef .withSym(this , sym.asType).reduceProjection
1140+ NamedType (this , sym, sym.name).reduceProjection
11461141
11471142// ----- Access to parts --------------------------------------------
11481143
@@ -1766,10 +1761,12 @@ object Types {
17661761 * provided `U` does not refer with a RecThis to the
17671762 * refinement type `T { X = U; ... }`
17681763 */
1769- def reduceProjection (implicit ctx : Context ): Type = {
1770- val reduced = prefix.lookupRefined(name)
1771- if (reduced.exists) reduced else this
1772- }
1764+ def reduceProjection (implicit ctx : Context ): Type =
1765+ if (isType) {
1766+ val reduced = prefix.lookupRefined(name)
1767+ if (reduced.exists) reduced else this
1768+ }
1769+ else this
17731770
17741771 def symbol (implicit ctx : Context ): Symbol = {
17751772 val now = ctx.period
@@ -2038,103 +2035,82 @@ object Types {
20382035 def apply (prefix : Type , designator : Name , denot : Denotation )(implicit ctx : Context ) =
20392036 if (designator.isTermName) TermRef (prefix, designator.asTermName, denot)
20402037 else TypeRef (prefix, designator.asTypeName, denot)
2041- def withSymAndName (prefix : Type , sym : Symbol , name : Name )(implicit ctx : Context ): NamedType =
2042- if (sym.isType) TypeRef .withSymAndName (prefix, sym.asType, name.asTypeName)
2043- else TermRef .withSymAndName (prefix, sym.asTerm, name.asTermName)
2038+ def apply (prefix : Type , sym : Symbol , name : Name )(implicit ctx : Context ): NamedType =
2039+ if (sym.isType) TypeRef .apply (prefix, sym.asType, name.asTypeName)
2040+ else TermRef .apply (prefix, sym.asTerm, name.asTermName)
20442041 }
20452042
20462043 object TermRef {
20472044
2048- private def symbolicRefs (implicit ctx : Context ) = ctx.phase.symbolicRefs
2049-
20502045 /** Create term ref with given name, without specifying a signature.
20512046 * Its meaning is the (potentially multi-) denotation of the member(s)
20522047 * of prefix with given name.
20532048 */
20542049 def apply (prefix : Type , designator : TermDesignator )(implicit ctx : Context ): TermRef =
20552050 ctx.uniqueNamedTypes.enterIfNew(prefix, designator, isTerm = true ).asInstanceOf [TermRef ]
20562051
2057- /** Create term ref referring to given symbol, taking the signature
2058- * from the symbol if it is completed, or creating a term ref without
2059- * signature, if symbol is not yet completed.
2052+ /** Create a term ref referring to given symbol with given name.
2053+ * This is similar to TermRef(Type, Symbol), except:
2054+ * (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
2055+ * (2) the designator of the TermRef is either the symbol or its name & unforced signature.
20602056 */
2061- def withSym (prefix : Type , sym : TermSymbol )(implicit ctx : Context ): TermRef =
2062- withSymAndName(prefix, sym, sym.name)
2057+ def apply (prefix : Type , sym : TermSymbol , name : TermName )(implicit ctx : Context ): TermRef =
2058+ if ((prefix eq NoPrefix ) || sym.isReferencedSymbolically)
2059+ apply(prefix, sym)
2060+ else
2061+ withSig(prefix, name.asTermName, sym.unforcedSignature).withSym(sym)
20632062
20642063 /** Create term ref to given initial denotation, taking the signature
20652064 * from the denotation if it is completed, or creating a term ref without
20662065 * signature, if denotation is not yet completed.
20672066 */
20682067 def apply (prefix : Type , designator : TermName , denot : Denotation )(implicit ctx : Context ): TermRef = {
2069- if ((prefix eq NoPrefix ) || denot.symbol.isReferencedSymbolically || symbolicRefs )
2070- withSym (prefix, denot.symbol.asTerm)
2068+ if ((prefix eq NoPrefix ) || denot.symbol.isReferencedSymbolically)
2069+ apply (prefix, denot.symbol.asTerm)
20712070 else denot match {
20722071 case denot : SymDenotation if denot.isCompleted => withSig(prefix, designator, denot.signature)
20732072 case _ => apply(prefix, designator)
20742073 }
20752074 } withDenot denot
20762075
2077- /** Create a term ref referring to given symbol with given name, taking the signature
2078- * from the symbol if it is completed, or creating a term ref without
2079- * signature, if symbol is not yet completed. This is very similar to TermRef(Type, Symbol),
2080- * except for two differences:
2081- * (1) The symbol might not yet have a denotation, so the name needs to be given explicitly.
2082- * (2) The name in the term ref need not be the same as the name of the Symbol.
2083- */
2084- def withSymAndName (prefix : Type , sym : TermSymbol , name : TermName )(implicit ctx : Context ): TermRef =
2085- if ((prefix eq NoPrefix ) || sym.isReferencedSymbolically|| symbolicRefs)
2086- apply(prefix, sym)
2087- else if (sym.defRunId != NoRunId && sym.isCompleted)
2088- withSig(prefix, name, sym.signature).withSym(sym)
2089- // Linker note:
2090- // this is problematic, as withSig method could return a hash-consed refference
2091- // that could have symbol already set making withSym trigger a double-binding error
2092- // ./tests/run/absoverride.scala demonstates this
2093- else
2094- withSig(prefix, name, Signature .NotAMethod ).withSym(sym)
2095-
20962076 /** Create a term ref to given symbol, taking the signature from the symbol
20972077 * (which must be completed).
20982078 */
20992079 def withSig (prefix : Type , sym : TermSymbol )(implicit ctx : Context ): TermRef =
2100- if ((prefix eq NoPrefix ) || sym.isReferencedSymbolically || symbolicRefs ) apply(prefix, sym)
2080+ if ((prefix eq NoPrefix ) || sym.isReferencedSymbolically) apply(prefix, sym)
21012081 else withSig(prefix, sym.name, sym.signature).withSym(sym)
21022082
21032083 /** Create a term ref with given prefix, name and signature */
2104- def withSig (prefix : Type , designator : TermName , sig : Signature )(implicit ctx : Context ): TermRef =
2105- apply(prefix, designator .withSig(sig))
2084+ def withSig (prefix : Type , name : TermName , sig : Signature )(implicit ctx : Context ): TermRef =
2085+ apply(prefix, name .withSig(sig))
21062086
21072087 /** Create a term ref with given prefix, name, signature, and initial denotation */
21082088 def withSigAndDenot (prefix : Type , name : TermName , sig : Signature , denot : Denotation )(implicit ctx : Context ): TermRef = {
2109- if ((prefix eq NoPrefix ) || denot.symbol.isReferencedSymbolically || symbolicRefs )
2089+ if ((prefix eq NoPrefix ) || denot.symbol.isReferencedSymbolically)
21102090 apply(prefix, denot.symbol.asTerm)
21112091 else
21122092 withSig(prefix, name, sig)
21132093 } withDenot denot
21142094 }
21152095
21162096 object TypeRef {
2097+
21172098 /** Create type ref with given prefix and name */
21182099 def apply (prefix : Type , desig : TypeDesignator )(implicit ctx : Context ): TypeRef =
21192100 ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false ).asInstanceOf [TypeRef ]
21202101
2121- /** Create type ref to given symbol */
2122- def withSym (prefix : Type , sym : TypeSymbol )(implicit ctx : Context ): TypeRef =
2123- withSymAndName(prefix, sym, sym.name)
2124-
2125- /** Create a type ref referring to given symbol with given name.
2126- * This is very similar to TypeRef(Type, Symbol),
2127- * except for two differences:
2128- * (1) The symbol might not yet have a denotation, so the name needs to be given explicitly.
2129- * (2) The name in the type ref need not be the same as the name of the Symbol.
2102+ /** Create a type ref referring to either a given symbol or its name.
2103+ * This is similar to TypeRef(prefix, sym), except:
2104+ * (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
2105+ * (2) the designator of the TypeRef is either the symbol or its name
21302106 */
2131- def withSymAndName (prefix : Type , sym : TypeSymbol , name : TypeName )(implicit ctx : Context ): TypeRef =
2107+ def apply (prefix : Type , sym : TypeSymbol , name : TypeName )(implicit ctx : Context ): TypeRef =
21322108 if ((prefix eq NoPrefix ) || sym.isReferencedSymbolically) apply(prefix, sym)
21332109 else apply(prefix, name).withSym(sym)
21342110
21352111 /** Create a type ref with given name and initial denotation */
21362112 def apply (prefix : Type , name : TypeName , denot : Denotation )(implicit ctx : Context ): TypeRef = {
2137- if ((prefix eq NoPrefix ) || denot.symbol.isReferencedSymbolically) withSym (prefix, denot.symbol.asType)
2113+ if ((prefix eq NoPrefix ) || denot.symbol.isReferencedSymbolically) apply (prefix, denot.symbol.asType)
21382114 else apply(prefix, name)
21392115 } withDenot denot
21402116 }
@@ -3421,7 +3397,7 @@ object Types {
34213397 appliedRefCache
34223398 }
34233399
3424- def symbolicTypeRef (implicit ctx : Context ): TypeRef = TypeRef .withSym (prefix, cls)
3400+ def symbolicTypeRef (implicit ctx : Context ): TypeRef = TypeRef (prefix, cls, cls.name )
34253401
34263402 // cached because baseType needs parents
34273403 private var parentsCache : List [Type ] = null
0 commit comments