From 6aa88d6dfe501a695183761c2b5f4bd201cdf2c0 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 6 Mar 2014 19:01:42 +0100 Subject: Main Typer reorg. Common code between tpd and Typer has been factored out into class TypeAssigner. --- src/dotty/tools/dotc/ast/CheckTrees.scala | 5 +- src/dotty/tools/dotc/ast/tpd.scala | 218 ++++---------- src/dotty/tools/dotc/core/pickling/UnPickler.scala | 4 +- src/dotty/tools/dotc/typer/Applications.scala | 41 ++- src/dotty/tools/dotc/typer/Checking.scala | 13 +- src/dotty/tools/dotc/typer/Namer.scala | 2 +- src/dotty/tools/dotc/typer/TypeAssigner.scala | 317 ++++++++++++++++++++- src/dotty/tools/dotc/typer/Typer.scala | 266 +++++------------ 8 files changed, 472 insertions(+), 394 deletions(-) (limited to 'src') diff --git a/src/dotty/tools/dotc/ast/CheckTrees.scala b/src/dotty/tools/dotc/ast/CheckTrees.scala index 1fae0a1f1..832544706 100644 --- a/src/dotty/tools/dotc/ast/CheckTrees.scala +++ b/src/dotty/tools/dotc/ast/CheckTrees.scala @@ -6,6 +6,7 @@ import core._ import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._ import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._ +// TODO: revise, integrate in a checking phase. object CheckTrees { import tpd._ @@ -19,7 +20,7 @@ object CheckTrees { def escapingRefs(block: Block)(implicit ctx: Context): collection.Set[NamedType] = { var hoisted: Set[Symbol] = Set() - lazy val locals = localSyms(block.stats).toSet + lazy val locals = ctx.typeAssigner.localSyms(block.stats).toSet def isLocal(sym: Symbol): Boolean = (locals contains sym) && !isHoistableClass(sym) def isHoistableClass(sym: Symbol) = @@ -177,7 +178,7 @@ object CheckTrees { checkRefinements(forbidden - rsym, rs1) case nil => } - checkRefinements(localSyms(refinements).toSet, refinements) + checkRefinements(ctx.typeAssigner.localSyms(refinements).toSet, refinements) case AppliedTypeTree(tpt, args) => check(tpt.isValueType) val tparams = tpt.tpe.typeParams diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala index 32a36bbd1..bda90b9e6 100644 --- a/src/dotty/tools/dotc/ast/tpd.scala +++ b/src/dotty/tools/dotc/ast/tpd.scala @@ -19,55 +19,35 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { sym.annotations map (_.tree)) def Ident(tp: NamedType)(implicit ctx: Context): Ident = - underlyingIfRepeated(untpd.Ident(tp.name) withType tp).checked + ta.assignType(untpd.Ident(tp.name), tp) def Select(qualifier: Tree, name: Name)(implicit ctx: Context): Select = - untpd.Select(qualifier, name).withType(qualifier.tpe select name) + ta.assignType(untpd.Select(qualifier, name), qualifier) def Select(qualifier: Tree, tp: NamedType)(implicit ctx: Context): Select = - untpd.Select(qualifier, tp.name).withType(tp).checked + untpd.Select(qualifier, tp.name).withType(tp) def SelectWithSig(qualifier: Tree, name: Name, sig: Signature)(implicit ctx: Context) = untpd.SelectWithSig(qualifier, name, sig) .withType(TermRef.withSig(qualifier.tpe, name.asTermName, sig)) + def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree = + ta.assignType(untpd.SelectFromTypeTree(qualifier, name), qualifier) + + def SelectFromTypeTree(qualifier: Tree, tp: NamedType)(implicit ctx: Context): SelectFromTypeTree = + untpd.SelectFromTypeTree(qualifier, tp.name).withType(tp) + def This(cls: ClassSymbol)(implicit ctx: Context): This = - untpd.This(cls.name).withType(cls.thisType).checked - - def Super(qual: Tree, mix: TypeName)(implicit ctx: Context): Super = { - val owntype = - if (mix.isEmpty) ctx.typeComparer.glb(qual.tpe.parents) - else { - val mixParents = qual.tpe.parents filter (_.name == mix) - check(mixParents.length == 1) - mixParents.head - } - untpd.Super(qual, mix).withType(SuperType(qual.tpe, owntype)).checked - } + ta.assignType(untpd.This(cls.name)) - def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = { - val owntype = fn.tpe.widen match { - case fntpe @ MethodType(pnames, ptypes) => - check(sameLength(ptypes, args), s"${fn.show}: ${fntpe.show} to ${args.map(_.show).mkString(", ")}") - fntpe.instantiate(args map (_.tpe)) - case t => - check(false, s"fn = $fn, args = $args, tp = $t") - ErrorType - } - untpd.Apply(fn, args).withType(owntype).checked - } + def Super(qual: Tree, mix: TypeName, inConstrCall: Boolean)(implicit ctx: Context): Super = + ta.assignType(untpd.Super(qual, mix), qual, inConstrCall) - def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = { - val owntype = fn.tpe.widen match { - case fntpe @ PolyType(pnames) => - check(sameLength(pnames, args)) - fntpe.instantiate(args map (_.tpe)) - case t => - check(false, s"bad type: $t") - ErrorType - } - untpd.TypeApply(fn, args).withType(owntype).checked - } + def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = + ta.assignType(untpd.Apply(fn, args), fn, args) + + def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = + ta.assignType(untpd.TypeApply(fn, args), fn, args) def Literal(const: Constant)(implicit ctx: Context): Literal = ta.assignType(untpd.Literal(const)) @@ -76,70 +56,33 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { Literal(Constant(())) def New(tpt: Tree)(implicit ctx: Context): New = - ta.assignType(untpd.New(tpt)) + ta.assignType(untpd.New(tpt), tpt) def New(tp: Type)(implicit ctx: Context): New = New(TypeTree(tp)) def Pair(left: Tree, right: Tree)(implicit ctx: Context): Pair = - untpd.Pair(left, right).withType(defn.PairType.appliedTo(left.tpe, right.tpe)).checked + ta.assignType(untpd.Pair(left, right), left, right) def Typed(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed = - untpd.Typed(expr, tpt).withType(tpt.tpe).checked + ta.assignType(untpd.Typed(expr, tpt), tpt) def NamedArg(name: Name, arg: Tree)(implicit ctx: Context) = - untpd.NamedArg(name, arg).withType(arg.tpe).checked + ta.assignType(untpd.NamedArg(name, arg), arg) def Assign(lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign = - untpd.Assign(lhs, rhs).withType(defn.UnitType).checked + ta.assignType(untpd.Assign(lhs, rhs)) def Block(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block = - untpd.Block(stats, expr).withType(avoid(expr.tpe, localSyms(stats))).checked - - def avoid(tp: Type, syms: => List[Symbol])(implicit ctx: Context): Type = { - val widenMap = new TypeMap { - lazy val forbidden = syms.toSet - def toAvoid(tp: Type): Boolean = tp match { - case tp: TermRef => - val sym = tp.symbol - sym.exists && ( - sym.owner.isTerm && (forbidden contains sym) - || !(sym.owner is Package) && toAvoid(tp.prefix) - ) - case _ => - false - } - def apply(tp: Type) = tp match { - case tp: TermRef if toAvoid(tp) && variance > 0 => - apply(tp.info) - case tp: TypeRef if toAvoid(tp.prefix) => - tp.info match { - case TypeAlias(ref) => apply(ref) - case _ => mapOver(tp) - } - case tp: RefinedType => - val tp1 @ RefinedType(parent1, _) = mapOver(tp) - if (tp1.refinedInfo existsPart toAvoid) { - typr.println(s"dropping refinement from $tp1") - parent1 - } - else tp1 - case _ => - mapOver(tp) - } - } - widenMap(tp) - } + ta.assignType(untpd.Block(stats, expr), stats, expr) def maybeBlock(stats: List[Tree], expr: Tree)(implicit ctx: Context): Tree = if (stats.isEmpty) expr else Block(stats, expr) def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = - untpd.If(cond, thenp, elsep).withType(thenp.tpe | elsep.tpe).checked + ta.assignType(untpd.If(cond, thenp, elsep), thenp, elsep) - def Closure(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = { - val ownType = if (tpt.isEmpty) meth.tpe.widen.toFunctionType else tpt.tpe - untpd.Closure(env, meth, tpt).withType(ownType).checked - } + def Closure(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = + ta.assignType(untpd.Closure(env, meth, tpt), meth, tpt) /** A function def * @@ -159,37 +102,30 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { Closure(Nil, Ident(TermRef(NoPrefix, meth)), targetTpt)) } - def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = - untpd.Match(selector, cases).withType(ctx.typeComparer.lub(cases.tpes)).checked - def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = - untpd.CaseDef(pat, guard, body).withType(body.tpe).checked + ta.assignType(untpd.CaseDef(pat, guard, body), body) + + def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = + ta.assignType(untpd.Match(selector, cases), cases) def Return(expr: Tree, from: Tree)(implicit ctx: Context): Return = - untpd.Return(expr, from).withType(defn.NothingType).checked + ta.assignType(untpd.Return(expr, from)) def Try(block: Tree, handler: Tree, finalizer: Tree)(implicit ctx: Context): Try = - untpd.Try(block, handler, finalizer).withType(block.tpe | handler.tpe).checked + ta.assignType(untpd.Try(block, handler, finalizer), block, handler) def Throw(expr: Tree)(implicit ctx: Context): Throw = - untpd.Throw(expr).withType(defn.NothingType).checked + ta.assignType(untpd.Throw(expr)) def SeqLiteral(elems: List[Tree])(implicit ctx: Context): SeqLiteral = - untpd.SeqLiteral(elems) - .withType(defn.SeqClass.typeRef.appliedTo(ctx.typeComparer.lub(elems.tpes))) - .checked - - def SeqLiteral(tpe: Type, elems: List[Tree])(implicit ctx: Context): SeqLiteral = { - val untpdSeqLit = - if (tpe derivesFrom defn.SeqClass) untpd.SeqLiteral(elems) - else untpd.JavaSeqLiteral(elems) - untpdSeqLit.withType(tpe).checked - } + ta.assignType(untpd.SeqLiteral(elems), elems) + + def SeqLiteral(tpe: Type, elems: List[Tree])(implicit ctx: Context): SeqLiteral = + if (tpe derivesFrom defn.SeqClass) SeqLiteral(elems) else JavaSeqLiteral(elems) def JavaSeqLiteral(elems: List[Tree])(implicit ctx: Context): SeqLiteral = new untpd.JavaSeqLiteral(elems) .withType(defn.ArrayClass.typeRef.appliedTo(ctx.typeComparer.lub(elems.tpes))) - .checked def TypeTree(original: Tree)(implicit ctx: Context): TypeTree = TypeTree(original.tpe, original) @@ -198,61 +134,41 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { untpd.TypeTree(original).withType(tp).checked def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree = - untpd.SingletonTypeTree(ref).withType(ref.tpe).checked - - def SelectFromTypeTree(qualifier: Tree, name: Name)(implicit ctx: Context): SelectFromTypeTree = - untpd.SelectFromTypeTree(qualifier, name).withType(qualifier.tpe select name).checked - - def SelectFromTypeTree(qualifier: Tree, tp: NamedType)(implicit ctx: Context): SelectFromTypeTree = - untpd.SelectFromTypeTree(qualifier, tp.name).withType(tp).checked + ta.assignType(untpd.SingletonTypeTree(ref), ref) def AndTypeTree(left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree = - untpd.AndTypeTree(left, right).withType(left.tpe & right.tpe).checked + ta.assignType(untpd.AndTypeTree(left, right), left, right) def OrTypeTree(left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree = - untpd.OrTypeTree(left, right).withType(left.tpe | right.tpe).checked + ta.assignType(untpd.OrTypeTree(left, right), left, right) - def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit ctx: Context): RefinedTypeTree = { - def refineType(tp: Type, refinement: Symbol): Type = - RefinedType(tp, refinement.name, refinement.info) - untpd.RefinedTypeTree(tpt, refinements) - .withType((tpt.tpe /: (refinements map (_.symbol)))(refineType)).checked - } - - def refineType(tp: Type, refinement: Symbol)(implicit ctx: Context): Type = - RefinedType(tp, refinement.name, refinement.info) + // RefinedTypeTree is missing, handled specially in Typer and Unpickler. - def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree = - untpd.AppliedTypeTree(tpt, args).withType(tpt.tpe.appliedTo(args map (_.tpe))).checked + def AppliedTypeTree(tycon: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree = + ta.assignType(untpd.AppliedTypeTree(tycon, args), tycon, args) def ByNameTypeTree(result: Tree)(implicit ctx: Context): ByNameTypeTree = - untpd.ByNameTypeTree(result).withType(ExprType(result.tpe)).checked + ta.assignType(untpd.ByNameTypeTree(result), result) def TypeBoundsTree(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree = - untpd.TypeBoundsTree(lo, hi).withType(TypeBounds(lo.tpe, hi.tpe)).checked + ta.assignType(untpd.TypeBoundsTree(lo, hi), lo, hi) def Bind(sym: TermSymbol, body: Tree)(implicit ctx: Context): Bind = - untpd.Bind(sym.name, body).withType(sym.termRef).checked + ta.assignType(untpd.Bind(sym.name, body), sym) def Alternative(trees: List[Tree])(implicit ctx: Context): Alternative = - untpd.Alternative(trees).withType(ctx.typeComparer.lub(trees map (_.tpe))).checked + ta.assignType(untpd.Alternative(trees), trees) - def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree])(implicit ctx: Context): UnApply = { - val owntype = fun.tpe.widen match { - case MethodType(_, paramType :: Nil) => paramType - case _ => check(false); ErrorType - } - untpd.UnApply(fun, implicits, patterns).withType(owntype).checked - } + def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree], proto: Type)(implicit ctx: Context): UnApply = + ta.assignType(untpd.UnApply(fun, implicits, patterns), proto) def ValDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): ValDef = - untpd.ValDef(Modifiers(sym), sym.name, TypeTree(sym.info), rhs).withType(sym.valRef).checked + ta.assignType(untpd.ValDef(Modifiers(sym), sym.name, TypeTree(sym.info), rhs), sym) def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef = - DefDef(sym, Function.const(rhs) _) + ta.assignType(DefDef(sym, Function.const(rhs) _), sym) def DefDef(sym: TermSymbol, rhsFn: List[List[Tree]] => Tree)(implicit ctx: Context): DefDef = { - val (tparams, mtp) = sym.info match { case tp: PolyType => val tparams = ctx.newTypeParams(sym, tp.paramNames, EmptyFlags, tp.instantiateBounds) @@ -271,15 +187,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { } val (vparamss, rtp) = valueParamss(mtp) val argss = vparamss map (_ map (vparam => Ident(vparam.termRef))) - untpd.DefDef( - Modifiers(sym), sym.name, tparams map TypeDef, - vparamss map (_ map (ValDef(_))), TypeTree(rtp), rhsFn(argss)) - .withType(sym.termRefWithSig).checked + ta.assignType( + untpd.DefDef( + Modifiers(sym), sym.name, tparams map TypeDef, + vparamss map (_ map (ValDef(_))), TypeTree(rtp), rhsFn(argss)), sym) } def TypeDef(sym: TypeSymbol)(implicit ctx: Context): TypeDef = - untpd.TypeDef(Modifiers(sym), sym.name, TypeTree(sym.info)) - .withType(sym.typeRef).checked + ta.assignType(untpd.TypeDef(Modifiers(sym), sym.name, TypeTree(sym.info)), sym) def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree])(implicit ctx: Context): TypeDef = { val parents = cls.info.parents map (TypeTree(_)) @@ -297,18 +212,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { .orElse(ctx.newLocalDummy(cls)) val impl = untpd.Template(constr, parents, selfType, newTypeParams ++ body) .withType(localDummy.termRef).checked - untpd.TypeDef(Modifiers(cls), cls.name, impl) - .withType(cls.typeRef).checked + ta.assignType(untpd.TypeDef(Modifiers(cls), cls.name, impl), cls) } def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = - untpd.Import(expr, selectors).withType(ctx.newImportSymbol(expr).termRef).checked + ta.assignType(untpd.Import(expr, selectors), ctx.newImportSymbol(expr)) def PackageDef(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef = - untpd.PackageDef(pid, stats).withType(pid.symbol.namedType).checked + ta.assignType(untpd.PackageDef(pid, stats), pid) def Annotated(annot: Tree, arg: Tree)(implicit ctx: Context): Annotated = - untpd.Annotated(annot, arg).withType(AnnotatedType(Annotation(annot), arg.tpe)).checked + ta.assignType(untpd.Annotated(annot, arg), annot, arg) // ------ Making references ------------------------------------------------------ @@ -323,14 +237,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { def ref(sym: Symbol)(implicit ctx: Context): tpd.NameTree = ref(NamedType(sym.owner.thisType, sym.name, sym.denot)) - // ----- Converting to releated trees ----------------------------------------------- - - def underlyingIfRepeated(id: Ident)(implicit ctx: Context): Ident = - if (id.isType) id else id withType id.tpe.underlyingIfRepeated - - def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree = - Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(defn.SeqClass, defn.RepeatedParamClass))) - // ------ Creating typed equivalents of trees that exist only in untyped form ------- /** new C(args) */ @@ -453,7 +359,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { } } override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context) = { - val locals = localSyms(trees) + val locals = ta.localSyms(trees) val mapped = ctx.mapSymbols(locals, typeMap, ownerMap) if (locals eq mapped) super.transform(trees) else withSubstitution(locals, mapped).transform(trees) @@ -476,7 +382,5 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo { // ensure that constructors are fully applied? // ensure that normal methods are fully applied? - def localSyms(stats: List[tpd.Tree])(implicit ctx: Context): List[Symbol] = - for (stat <- stats if stat.isDef) yield stat.symbol } diff --git a/src/dotty/tools/dotc/core/pickling/UnPickler.scala b/src/dotty/tools/dotc/core/pickling/UnPickler.scala index c69f60758..622752570 100644 --- a/src/dotty/tools/dotc/core/pickling/UnPickler.scala +++ b/src/dotty/tools/dotc/core/pickling/UnPickler.scala @@ -988,7 +988,7 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot: case UNAPPLYtree => val fun = readTreeRef() val args = until(end, readTreeRef) - UnApply(fun, Nil, args) // !!! this is wrong in general + UnApply(fun, Nil, args, defn.AnyType) // !!! this is wrong in general case ARRAYVALUEtree => val elemtpt = readTreeRef() @@ -1067,7 +1067,7 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot: setSym() val qual = readTreeRef() val mix = readTypeNameRef() - Super(qual, mix) + Super(qual, mix, inConstrCall = false) // todo: revise case THIStree => setSym() diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala index 26325e57e..cf0d7d0a1 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -398,8 +398,9 @@ trait Applications extends Compatibility { self: Typer => val result = { var typedArgs = typedArgBuf.toList - val ownType = - if (!success) ErrorType + val app0 = cpy.Apply(app, normalizedFun, typedArgs) + val app1 = + if (!success) app0.withType(ErrorType) else { if (!sameSeq(args, orderedArgs)) { // need to lift arguments to maintain evaluation order in the @@ -411,9 +412,9 @@ trait Applications extends Compatibility { self: Typer => } if (sameSeq(typedArgs, args)) // trick to cut down on tree copying typedArgs = args.asInstanceOf[List[Tree]] - methodType.instantiate(typedArgs.tpes) + assignType(app0, normalizedFun, typedArgs) } - wrapDefs(liftedDefs, cpy.Apply(app, normalizedFun, typedArgs).withType(ownType)) + wrapDefs(liftedDefs, app1) } } @@ -513,21 +514,11 @@ trait Applications extends Compatibility { self: Typer => def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context): Tree = track("typedTypeApply") { val typedArgs = tree.args mapconserve (typedType(_)) val typedFn = typedExpr(tree.fun, PolyProto(typedArgs.tpes, pt)) - val ownType = typedFn.tpe.widen match { - case pt: PolyType => - checkBounds(typedArgs, pt, tree.pos) - val argTypes = typedArgs.tpes - if (argTypes.length == pt.paramNames.length) - pt.resultType.substParams(pt, typedArgs.tpes) - else { - ctx.error(i"wrong number of type parameters for ${typedFn.tpe}; expected: ${pt.paramNames.length}", tree.pos) - ErrorType - } + typedFn.tpe.widen match { + case pt: PolyType => checkBounds(typedArgs, pt, tree.pos) case _ => - ctx.error(s"${err.exprStr(typedFn)} does not take type parameters", tree.pos) - ErrorType } - cpy.TypeApply(tree, typedFn, typedArgs).withType(ownType) + assignType(cpy.TypeApply(tree, typedFn, typedArgs), typedFn, typedArgs) } def typedUnApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = track("typedUnApply") { @@ -577,13 +568,13 @@ trait Applications extends Compatibility { self: Typer => /** Produce a typed qual.unappy or qual.unappySeq tree, or * else if this fails follow a type alias and try again. */ - val unapply = trySelectUnapply(qual) { sel => + val unapplyFn = trySelectUnapply(qual) { sel => val qual1 = followTypeAlias(qual) if (qual1.isEmpty) notAnExtractor(sel) else trySelectUnapply(qual1)(_ => notAnExtractor(sel)) } - def fromScala2x = unapply.symbol.exists && (unapply.symbol.owner is Scala2x) + def fromScala2x = unapplyFn.symbol.exists && (unapplyFn.symbol.owner is Scala2x) def unapplyArgs(unapplyResult: Type)(implicit ctx: Context): List[Type] = { def extractorMemberType(tp: Type, name: Name) = { @@ -609,7 +600,7 @@ trait Applications extends Compatibility { self: Typer => // println(s"unapply $unapplyResult ${extractorMemberType(unapplyResult, nme.isDefined)}") if (extractorMemberType(unapplyResult, nme.isDefined) isRef defn.BooleanClass) { if (getTp.exists) - if (unapply.symbol.name == nme.unapplySeq) { + if (unapplyFn.symbol.name == nme.unapplySeq) { val seqArg = boundsToHi(getTp.firstBaseArgInfo(defn.SeqClass)) if (seqArg.exists) return args map Function.const(seqArg) } @@ -634,7 +625,7 @@ trait Applications extends Compatibility { self: Typer => case _ => false } - unapply.tpe.widen match { + unapplyFn.tpe.widen match { case mt: MethodType if mt.paramTypes.length == 1 && !mt.isDependent => val unapplyArgType = mt.paramTypes.head unapp.println(s"unapp arg tpe = ${unapplyArgType.show}, pt = ${pt.show}") @@ -661,7 +652,7 @@ trait Applications extends Compatibility { self: Typer => // can open unsoundness holes. See SI-7952 for an example of the hole this opens. if (ctx.settings.verbose.value) ctx.warning(msg, tree.pos) } else { - unapp.println(s" ${unapply.symbol.owner} ${unapply.symbol.owner is Scala2x}") + unapp.println(s" ${unapplyFn.symbol.owner} ${unapplyFn.symbol.owner is Scala2x}") ctx.error(msg, tree.pos) } case _ => @@ -677,7 +668,7 @@ trait Applications extends Compatibility { self: Typer => } val dummyArg = dummyTreeOfType(unapplyArgType) - val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapply, dummyArg :: Nil))) + val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil))) val unapplyImplicits = unapplyApp match { case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); args2 case Apply(unapply, `dummyArg` :: Nil) => Nil @@ -695,12 +686,12 @@ trait Applications extends Compatibility { self: Typer => List.fill(argTypes.length - args.length)(WildcardType) } val unapplyPatterns = (bunchedArgs, argTypes).zipped map (typed(_, _)) - val result = cpy.UnApply(tree, unapply, unapplyImplicits, unapplyPatterns) withType ownType + val result = assignType(cpy.UnApply(tree, unapplyFn, unapplyImplicits, unapplyPatterns), ownType) unapp.println(s"unapply patterns = $unapplyPatterns") if ((ownType eq pt) || ownType.isError) result else Typed(result, TypeTree(ownType)) case tp => - val unapplyErr = if (tp.isError) unapply else notAnExtractor(unapply) + val unapplyErr = if (tp.isError) unapplyFn else notAnExtractor(unapplyFn) val typedArgsErr = args mapconserve (typed(_, defn.AnyType)) cpy.UnApply(tree, unapplyErr, Nil, typedArgsErr) withType ErrorType } diff --git a/src/dotty/tools/dotc/typer/Checking.scala b/src/dotty/tools/dotc/typer/Checking.scala index 5c21584bd..25e6a7aa7 100644 --- a/src/dotty/tools/dotc/typer/Checking.scala +++ b/src/dotty/tools/dotc/typer/Checking.scala @@ -5,7 +5,7 @@ package typer import core._ import ast._ import Contexts._, Types._, Flags._, Denotations._, Names._, StdNames._, NameOps._, Symbols._ -import Trees._ +import Trees._, ProtoTypes._ import Constants._ import Scopes._ import annotation.unchecked @@ -20,6 +20,7 @@ import collection.mutable trait NoChecking { import tpd._ + def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = tree def checkBounds(args: List[tpd.Tree], poly: PolyType, pos: Position)(implicit ctx: Context): Unit = () def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit = () def checkClassTypeWithStablePrefix(tp: Type, pos: Position, traitReq: Boolean)(implicit ctx: Context): Type = tp @@ -33,6 +34,16 @@ trait Checking extends NoChecking { import tpd._ + /** Check that Java statics and packages can only be used in selections. + */ + override def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = { + if (!proto.isInstanceOf[SelectionProto]) { + val sym = tree.tpe.termSymbol + if ((sym is Package) || (sym is JavaModule)) ctx.error(i"$sym is not a value", tree.pos) + } + tree + } + /** Check that type arguments `args` conform to corresponding bounds in `poly` */ override def checkBounds(args: List[tpd.Tree], poly: PolyType, pos: Position)(implicit ctx: Context): Unit = for ((arg, bounds) <- args zip poly.paramBounds) { diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala index 6e91e4754..c24021936 100644 --- a/src/dotty/tools/dotc/typer/Namer.scala +++ b/src/dotty/tools/dotc/typer/Namer.scala @@ -591,7 +591,7 @@ class Namer { typer: Typer => (paramSymss.isEmpty || paramSymss.head.nonEmpty && (paramSymss.head.head is Implicit))) paramSymss = Nil :: paramSymss val restpe1 = // try to make anonymous functions non-dependent, so that they can be used in closures - if (name == nme.ANON_FUN) tpd.avoid(restpe, paramSymss.flatten) + if (name == nme.ANON_FUN) avoid(restpe, paramSymss.flatten) else restpe val monotpe = (paramSymss :\ restpe1) { (params, restpe) => diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala index e711ee949..6eeec56e1 100644 --- a/src/dotty/tools/dotc/typer/TypeAssigner.scala +++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala @@ -4,15 +4,182 @@ package typer import core._ import ast._ -import Scopes._, Contexts._, Constants._, Types._, Symbols._ +import Scopes._, Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._ +import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._ +import util.Positions._ +import config.Printers._ -trait TypeAssigner extends NoChecking { +trait TypeAssigner { + import tpd._ - def assignType(tree: untpd.New)(implicit ctx: Context) = { - checkClassTypeWithStablePrefix(tree.tpt.tpe, tree.tpt.pos, traitReq = false) - tree.withType(tree.tpt.tpe) + /** The enclosing class, except if we are in a super call, in which case + * it is the next outer one. + */ + def effectiveEnclosingClass(implicit ctx: Context) = { + val enclClass = ctx.owner.enclosingClass + if ((ctx.mode is Mode.InSuperCall) && enclClass.exists) enclClass.owner.enclosingClass + else enclClass } + /** The qualifying class of a this or super with prefix `qual` (which might be empty). + * @param packageOk The qualifier may refer to a package. + */ + def qualifyingClass(tree: untpd.Tree, qual: Name, packageOK: Boolean)(implicit ctx: Context): Symbol = { + effectiveEnclosingClass.ownersIterator.find(o => qual.isEmpty || o.isClass && o.name == qual) match { + case Some(c) if packageOK || !(c is Package) => + c + case _ => + ctx.error( + if (qual.isEmpty) tree.show + " can be used only in a class, object, or template" + else qual.show + " is not an enclosing class", tree.pos) + NoSymbol + } + } + + def avoid(tp: Type, syms: => List[Symbol])(implicit ctx: Context): Type = { + val widenMap = new TypeMap { + lazy val forbidden = syms.toSet + def toAvoid(tp: Type): Boolean = tp match { + case tp: TermRef => + val sym = tp.symbol + sym.exists && ( + sym.owner.isTerm && (forbidden contains sym) + || !(sym.owner is Package) && toAvoid(tp.prefix) + ) + case _ => + false + } + def apply(tp: Type) = tp match { + case tp: TermRef if toAvoid(tp) && variance > 0 => + apply(tp.info) + case tp: TypeRef if toAvoid(tp.prefix) => + tp.info match { + case TypeAlias(ref) => apply(ref) + case _ => mapOver(tp) + } + case tp: RefinedType => + val tp1 @ RefinedType(parent1, _) = mapOver(tp) + if (tp1.refinedInfo existsPart toAvoid) { + typr.println(s"dropping refinement from $tp1") + parent1 + } + else tp1 + case _ => + mapOver(tp) + } + } + widenMap(tp) + } + + def localSyms(stats: List[tpd.Tree])(implicit ctx: Context): List[Symbol] = + for (stat <- stats if stat.isDef) yield stat.symbol + + def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree = + Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(defn.SeqClass, defn.RepeatedParamClass))) + + /** A denotation exists really if it exists and does not point to a stale symbol. */ + final def reallyExists(denot: Denotation)(implicit ctx: Context): Boolean = try + denot match { + case denot: SymDenotation => + denot.exists && { + denot.ensureCompleted + !denot.isAbsent + } + case denot: SingleDenotation => + val sym = denot.symbol + (sym eq NoSymbol) || reallyExists(sym.denot) + case _ => + true + } + catch { + case ex: StaleSymbol => false + } + + /** If `tpe` is a named type, check that its denotation is accessible in the + * current context. Return the type with those alternatives as denotations + * which are accessible. + */ + def ensureAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = { + def test(tpe: Type, firstTry: Boolean): Type = tpe match { + case tpe: NamedType => + val pre = tpe.prefix + val name = tpe.name + val d = tpe.denot.accessibleFrom(pre, superAccess) + if (!d.exists) { + // it could be that we found an inaccessbile private member, but there is + // an inherited non-private member with the same name and signature. + val d2 = pre.nonPrivateMember(name) + if (reallyExists(d2) && firstTry) test(pre.select(name, d2), false) + else { + val alts = tpe.denot.alternatives.map(_.symbol).filter(_.exists) + val what = alts match { + case Nil => + name.toString + case sym :: Nil => + if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated + case _ => + i"none of the overloaded alternatives named $name" + } + val where = if (ctx.owner.exists) s" from ${ctx.owner.enclosingClass}" else "" + val whyNot = new StringBuffer + alts foreach (_.isAccessibleFrom(pre, superAccess, whyNot)) + if (!tpe.isError) + ctx.error(i"$what cannot be accessed as a member of $pre$where.$whyNot", pos) + ErrorType + } + } else if (d.symbol is TypeParamAccessor) // always dereference type param accessors + ensureAccessible(d.info.bounds.hi, superAccess, pos) + else + tpe withDenot d + case _ => + tpe + } + test(tpe, true) + } + + /** The type of a selection with `name` of a tree with type `site`. + */ + def selectionType(site: Type, name: Name, pos: Position)(implicit ctx: Context): Type = { + val mbr = site.member(name) + if (reallyExists(mbr)) site.select(name, mbr) + else { + if (!site.isErroneous) { + ctx.error( + if (name == nme.CONSTRUCTOR) i"$site does not have a constructor" + else i"$name is not a member of $site", pos) + } + ErrorType + } + } + + /** The selection type, which is additionally checked for accessibility. + */ + def accessibleSelectionType(tree: untpd.RefTree, qual1: Tree)(implicit ctx: Context): Type = { + val ownType = selectionType(qual1.tpe.widenIfUnstable, tree.name, tree.pos) + ensureAccessible(ownType, qual1.isInstanceOf[Super], tree.pos) + } + + /** Type assignment method. Each method takes as parameters + * - an untpd.Tree to which it assigns a type, + * - typed child trees it needs to access to cpmpute that type, + * - any further information it needs to access to compute that type. + */ + + def assignType(tree: untpd.Ident, rawType: Type)(implicit ctx: Context) = { + tree.withType(if (tree.isType) rawType else rawType.underlyingIfRepeated) + } + + def assignType(tree: untpd.Select, qual: Tree)(implicit ctx: Context) = { + tree.withType(accessibleSelectionType(tree, qual)) + } + + def assignType(tree: untpd.SelectFromTypeTree, qual: Tree)(implicit ctx: Context) = { + tree.withType(accessibleSelectionType(tree, qual)) + } + + def assignType(tree: untpd.New, tpt: Tree)(implicit ctx: Context) = + tree.withType(tpt.tpe) + def assignType(tree: untpd.Literal)(implicit ctx: Context) = tree.withType { tree.const.tag match { @@ -21,6 +188,146 @@ trait TypeAssigner extends NoChecking { case _ => ConstantType(tree.const) } } + + def assignType(tree: untpd.This)(implicit ctx: Context) = { + val cls = qualifyingClass(tree, tree.qual, packageOK = false) + tree.withType(cls.thisType) + } + + def assignType(tree: untpd.Super, qual: Tree, inConstrCall: Boolean)(implicit ctx: Context) = { + val mix = tree.mix + val cls = qual.tpe.widen.typeSymbol + + def findMixinSuper(site: Type): Type = site.parents filter (_.name == mix) match { + case p :: Nil => + p + case Nil => + errorType(i"$mix does not name a parent class of $cls", tree.pos) + case p :: q :: _ => + errorType(s"ambiguous parent class qualifier", tree.pos) + } + val owntype = + if (!mix.isEmpty) findMixinSuper(cls.info) + else if (inConstrCall) cls.info.firstParent + else cls.info.parents.reduceLeft((x: Type, y: Type) => AndType(x, y)) + tree.withType(SuperType(cls.thisType, owntype)) + } + + def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context) = { + val ownType = fn.tpe.widen match { + case fntpe @ MethodType(_, ptypes) => + if (sameLength(ptypes, args)) fntpe.instantiate(args.tpes) + else errorType(s"wrong number of type parameters for ${fn.tpe}; expected: ${ptypes.length}", tree.pos) + case t => + errorType(s"${err.exprStr(fn)} does not take type parameters", tree.pos) + } + tree.withType(ownType) + } + + def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(implicit ctx: Context) = { + val ownType = fn.tpe.widen match { + case pt: PolyType => + val argTypes = args.tpes + if (sameLength(argTypes, pt.paramNames)) pt.instantiate(args.tpes) + else errorType(i"wrong number of type parameters for ${fn.tpe}; expected: ${pt.paramNames.length}", tree.pos) + case _ => + errorType(s"${err.exprStr(fn)} does not take type parameters", tree.pos) + } + tree.withType(ownType) + } + + def assignType(tree: untpd.Pair, left: Tree, right: Tree)(implicit ctx: Context) = + tree.withType(defn.PairType.appliedTo(left.tpe :: right.tpe :: Nil)) + + def assignType(tree: untpd.Typed, tpt: Tree)(implicit ctx: Context) = + tree.withType(tpt.tpe) + + def assignType(tree: untpd.NamedArg, arg: Tree)(implicit ctx: Context) = + tree.withType(arg.tpe) + + def assignType(tree: untpd.Assign)(implicit ctx: Context) = + tree.withType(defn.UnitType) + + def assignType(tree: untpd.Block, stats: List[Tree], expr: Tree)(implicit ctx: Context) = + tree.withType(avoid(expr.tpe, localSyms(stats))) + + def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(implicit ctx: Context) = + tree.withType(thenp.tpe | elsep.tpe) + + def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(implicit ctx: Context) = + tree.withType(if (target.isEmpty) meth.tpe.widen.toFunctionType else target.tpe) + + def assignType(tree: untpd.CaseDef, body: Tree)(implicit ctx: Context) = + tree.withType(body.tpe) + + def assignType(tree: untpd.Match, cases: List[CaseDef])(implicit ctx: Context) = + tree.withType(ctx.typeComparer.lub(cases.tpes)) + + def assignType(tree: untpd.Return)(implicit ctx: Context) = + tree.withType(defn.NothingType) + + def assignType(tree: untpd.Try, expr: Tree, handler: Tree)(implicit ctx: Context) = { + val handlerTypeArgs = handler.tpe.baseArgTypesHi(defn.FunctionClass(1)) + tree.withType(if (handlerTypeArgs.nonEmpty) expr.tpe | handlerTypeArgs(1) else expr.tpe) + } + + def assignType(tree: untpd.Throw)(implicit ctx: Context) = + tree.withType(defn.NothingType) + + def assignType(tree: untpd.SeqLiteral, elems: List[Tree])(implicit ctx: Context) = + tree.withType(defn.SeqType.appliedTo(ctx.typeComparer.lub(elems.tpes))) + + def assignType(tree: untpd.SingletonTypeTree, ref: Tree)(implicit ctx: Context) = + tree.withType(ref.tpe) + + def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context) = + tree.withType(left.tpe & right.tpe) + + def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context) = + tree.withType(left.tpe | right.tpe) + + // RefinedTypeTree is missing, handled specially in Typer and Unpickler. + + def assignType(tree: untpd.AppliedTypeTree, tycon: Tree, args: List[Tree])(implicit ctx: Context) = { + val tparams = tycon.tpe.typeParams + val ownType = + if (sameLength(tparams, args)) tycon.tpe.appliedTo(args.tpes) + else errorType(i"wrong number of type arguments for ${tycon.tpe}, should be ${tparams.length}", tree.pos) + tree.withType(ownType) + } + + def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context) = + tree.withType(ExprType(result.tpe)) + + def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree)(implicit ctx: Context) = + tree.withType(TypeBounds(lo.tpe, hi.tpe)) + + def assignType(tree: untpd.Bind, sym: TermSymbol)(implicit ctx: Context) = + tree.withType(TermRef(NoPrefix, sym)) + + def assignType(tree: untpd.Alternative, trees: List[Tree])(implicit ctx: Context) = + tree.withType(ctx.typeComparer.lub(trees.tpes)) + + def assignType(tree: untpd.UnApply, proto: Type)(implicit ctx: Context) = + tree.withType(proto) + + def assignType(tree: untpd.ValDef, sym: Symbol)(implicit ctx: Context) = + tree.withType(if (sym.exists) sym.valRef else NoType) + + def assignType(tree: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = + tree.withType(sym.termRefWithSig) + + def assignType(tree: untpd.TypeDef, sym: Symbol)(implicit ctx: Context) = + tree.withType(sym.typeRef) + + def assignType(tree: untpd.Import, sym: Symbol)(implicit ctx: Context) = + tree.withType(sym.termRef) + + def assignType(tree: untpd.Annotated, annot: Tree, arg: Tree)(implicit ctx: Context) = + tree.withType(AnnotatedType(Annotation(annot), arg.tpe)) + + def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) = + tree.withType(pid.symbol.valRef) } object TypeAssigner extends TypeAssigner diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala index c545641a0..51eba3b02 100644 --- a/src/dotty/tools/dotc/typer/Typer.scala +++ b/src/dotty/tools/dotc/typer/Typer.scala @@ -62,120 +62,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit */ private var importedFromRoot: Set[Symbol] = Set() - /** A denotation exists really if it exists and does not point to a stale symbol. */ - final def reallyExists(denot: Denotation)(implicit ctx: Context): Boolean = try - denot match { - case denot: SymDenotation => - denot.exists && { - denot.ensureCompleted - !denot.isAbsent - } - case denot: SingleDenotation => - val sym = denot.symbol - (sym eq NoSymbol) || reallyExists(sym.denot) - case _ => - true - } - catch { - case ex: StaleSymbol => false - } - - /** The type of a selection with `name` of a tree with type `site`. - */ - def selectionType(site: Type, name: Name, pos: Position)(implicit ctx: Context): Type = { - val mbr = site.member(name) - if (reallyExists(mbr)) site.select(name, mbr) - else { - if (!site.isErroneous) { - ctx.error( - if (name == nme.CONSTRUCTOR) i"$site does not have a constructor" - else i"$name is not a member of $site", pos) - } - ErrorType - } - } - - /** The selection type, which is additionally checked for accessibility. - */ - def checkedSelectionType(qual1: Tree, tree: untpd.RefTree)(implicit ctx: Context): Type = { - val ownType = selectionType(qual1.tpe.widenIfUnstable, tree.name, tree.pos) - checkAccessible(ownType, qual1.isInstanceOf[Super], tree.pos) - } - - /** Check that Java statics and packages can only be used in selections. - */ - def checkValue(tpe: Type, proto: Type, pos: Position)(implicit ctx: Context): Unit = - if (!proto.isInstanceOf[SelectionProto]) { - val sym = tpe.termSymbol - if ((sym is Package) || (sym is JavaModule)) ctx.error(i"$sym is not a value", pos) - } - - /** If `tpe` is a named type, check that its denotation is accessible in the - * current context. Return the type with those alternatives as denotations - * which are accessible. - */ - def checkAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = { - def test(tpe: Type, firstTry: Boolean): Type = tpe match { - case tpe: NamedType => - val pre = tpe.prefix - val name = tpe.name - val d = tpe.denot.accessibleFrom(pre, superAccess) - if (!d.exists) { - // it could be that we found an inaccessbile private member, but there is - // an inherited non-private member with the same name and signature. - val d2 = pre.nonPrivateMember(name) - if (reallyExists(d2) && firstTry) test(pre.select(name, d2), false) - else { - val alts = tpe.denot.alternatives.map(_.symbol).filter(_.exists) - val what = alts match { - case Nil => - name.toString - case sym :: Nil => - if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated - case _ => - i"none of the overloaded alternatives named $name" - } - val where = if (ctx.owner.exists) s" from ${ctx.owner.enclosingClass}" else "" - val whyNot = new StringBuffer - alts foreach (_.isAccessibleFrom(pre, superAccess, whyNot)) - if (!tpe.isError) - ctx.error(i"$what cannot be accessed as a member of $pre$where.$whyNot", pos) - ErrorType - } - } else if (d.symbol is TypeParamAccessor) // always dereference type param accessors - checkAccessible(d.info.bounds.hi, superAccess, pos) - else - tpe withDenot d - case _ => - tpe - } - test(tpe, true) - } - - /** The enclosing class, except if we are in a super call, in which case - * it is the next outer one. - */ - def effectiveEnclosingClass(implicit ctx: Context) = { - val enclClass = ctx.owner.enclosingClass - if ((ctx.mode is Mode.InSuperCall) && enclClass.exists) enclClass.owner.enclosingClass - else enclClass - } - - /** The qualifying class of a this or super with prefix `qual` (which might be empty). - * @param packageOk The qualifier may refer to a package. - */ - def qualifyingClass(tree: untpd.Tree, qual: Name, packageOK: Boolean)(implicit ctx: Context): Symbol = { - effectiveEnclosingClass.ownersIterator.find(o => qual.isEmpty || o.isClass && o.name == qual) match { - case Some(c) if packageOK || !(c is Package) => - c - case _ => - ctx.error( - if (qual.isEmpty) tree.show + " can be used only in a class, object, or template" - else qual.show + " is not an enclosing class", tree.pos) - NoSymbol - } - } - /** Attribute an identifier consisting of a simple name or wildcard * * @param tree The tree representing the identifier. @@ -366,50 +252,38 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val rawType = try findRef(NoType, BindingPrec.nothingBound, NoContext) finally importedFromRoot = saved - checkValue(rawType, pt, tree.pos) val ownType = if (rawType.exists) - checkAccessible(rawType, superAccess = false, tree.pos) + ensureAccessible(rawType, superAccess = false, tree.pos) else { error(i"not found: $kind$name", tree.pos) ErrorType } - tree.withType(ownType.underlyingIfRepeated) + checkValue(tree.withType(ownType.underlyingIfRepeated), pt) } def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") { val qual1 = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this)) - val ownType = checkedSelectionType(qual1, tree) - checkValue(ownType, pt, tree.pos) - cpy.Select(tree, qual1, tree.name).withType(ownType) + checkValue(assignType(cpy.Select(tree, qual1, tree.name), qual1), pt) + } + + def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): SelectFromTypeTree = track("typedSelectFromTypeTree") { + val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this)) + assignType(cpy.SelectFromTypeTree(tree, qual1, tree.name), qual1) } def typedThis(tree: untpd.This)(implicit ctx: Context): Tree = track("typedThis") { - val cls = qualifyingClass(tree, tree.qual, packageOK = false) - tree.withType(cls.thisType) + assignType(tree) } def typedSuper(tree: untpd.Super, pt: Type)(implicit ctx: Context): Tree = track("typedSuper") { - val mix = tree.mix val qual1 = typed(tree.qual) - val cls = qual1.tpe.widen.typeSymbol - - def findMixinSuper(site: Type): Type = site.parents filter (_.name == mix) match { - case p :: Nil => - p - case Nil => - errorType(i"$mix does not name a parent class of $cls", tree.pos) - case p :: q :: _ => - errorType(s"ambiguous parent class qualifier", tree.pos) + val inConstrCall = pt match { + case pt: SelectionProto if pt.name == nme.CONSTRUCTOR => true + case _ => false } - val owntype = - if (!mix.isEmpty) findMixinSuper(cls.info) - else pt match { - case pt: SelectionProto if pt.name == nme.CONSTRUCTOR => cls.info.firstParent - case _ => cls.info.parents.reduceLeft((x: Type, y: Type) => AndType(x, y)) - } - cpy.Super(tree, qual1, mix).withType(SuperType(cls.thisType, owntype)) + assignType(cpy.Super(tree, qual1, tree.mix), qual1, inConstrCall) } def typedLiteral(tree: untpd.Literal)(implicit ctx: Context) = track("typedLiteral") { @@ -425,7 +299,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit typed(cpy.Block(tree, clsDef :: Nil, New(Ident(x), Nil)), pt) case _ => val tpt1 = typedType(tree.tpt) - assignType(cpy.New(tree, tpt1)) + checkClassTypeWithStablePrefix(tpt1.tpe, tpt1.pos, traitReq = false) + assignType(cpy.New(tree, tpt1), tpt1) // todo in a later phase: checkInstantiatable(cls, tpt1.pos) } } @@ -437,7 +312,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } val left1 = typed(tree.left, leftProto) val right1 = typed(tree.right, rightProto) - cpy.Pair(tree, left1, right1).withType(defn.PairType.appliedTo(left1.tpe :: right1.tpe :: Nil)) + assignType(cpy.Pair(tree, left1, right1), left1, right1) } def typedTyped(tree: untpd.Typed, pt: Type)(implicit ctx: Context): Tree = track("typedTyped") { @@ -446,7 +321,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val expr1 = if (isWildcard) tree.expr withType tpt1.tpe else typedExpr(tree.expr, tpt1.tpe) - cpy.Typed(tree, expr1, tpt1).withType(tpt1.tpe) + assignType(cpy.Typed(tree, expr1, tpt1), tpt1) } tree.expr match { case id: untpd.Ident if (ctx.mode is Mode.Pattern) && isVarPattern(id) => @@ -465,7 +340,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def typedNamedArg(tree: untpd.NamedArg, pt: Type)(implicit ctx: Context) = track("typedNamedArg") { val arg1 = typed(tree.arg, pt) - cpy.NamedArg(tree, tree.name, arg1).withType(arg1.tpe) + assignType(cpy.NamedArg(tree, tree.name, arg1), arg1) } def typedAssign(tree: untpd.Assign, pt: Type)(implicit ctx: Context) = track("typedAssign") { @@ -481,7 +356,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def lhs1 = typed(untpd.TypedSplice(lhsCore)) lhsCore.tpe match { case ref: TermRef if ref.symbol is (Mutable, butNot = Accessor) => - cpy.Assign(tree, lhs1, typed(tree.rhs, ref.info)).withType(defn.UnitType) + assignType(cpy.Assign(tree, lhs1, typed(tree.rhs, ref.info))) case _ => def reassignmentToVal = errorTree(cpy.Assign(tree, lhsCore, typed(tree.rhs, lhs1.tpe.widen)), @@ -494,7 +369,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit lhsCore match { case lhsCore: RefTree if setter.exists => val setterTypeRaw = pre select (setterName, setter) - val setterType = checkAccessible(setterTypeRaw, isSuperSelection(lhsCore), tree.pos) + val setterType = ensureAccessible(setterTypeRaw, isSuperSelection(lhsCore), tree.pos) val lhs2 = lhsCore.withName(setterName).withType(setterType) typed(cpy.Apply(tree, untpd.TypedSplice(lhs2), tree.rhs :: Nil)) case _ => @@ -511,8 +386,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val exprCtx = index(tree.stats) val stats1 = typedStats(tree.stats, ctx.owner) val expr1 = typedExpr(tree.expr, pt)(exprCtx) - val result = cpy.Block(tree, stats1, expr1).withType(avoid(expr1.tpe, localSyms(stats1))) - checkNoLocalRefs(result, pt) + ensureNoLocalRefs(assignType(cpy.Block(tree, stats1, expr1), stats1, expr1), pt) } /** Check that block's type can be expressed without references to locally defined @@ -522,17 +396,18 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit * 2. If (1) fails, force all type variables so that the block's type is * fully defined and try again. */ - def checkNoLocalRefs(block: Block, pt: Type, forcedDefined: Boolean = false)(implicit ctx: Context): Tree = { + private def ensureNoLocalRefs(block: Block, pt: Type, forcedDefined: Boolean = false)(implicit ctx: Context): Tree = { val Block(stats, expr) = block val leaks = CheckTrees.escapingRefs(block) if (leaks.isEmpty) block else if (isFullyDefined(pt, ForceDegree.all)) { - val expr1 = typed(untpd.Typed(untpd.TypedSplice(expr), untpd.TypeTree(pt))) - untpd.Block(stats, expr1) withType expr1.tpe + val expr1 = Typed(expr, TypeTree(pt)) + cpy.Block(block, stats, expr1) withType expr1.tpe // no assignType here because avoid is redundant } else if (!forcedDefined) { fullyDefinedType(block.tpe, "block", block.pos) - val block1 = block.withType(avoid(block.tpe, localSyms(stats))) - checkNoLocalRefs(block1, pt, forcedDefined = true) + val expr1 = Typed(expr, TypeTree(avoid(block.tpe, localSyms(stats)))) + val block1 = cpy.Block(block, stats, expr1) withType expr1.tpe // no assignType here because avoid is already done + ensureNoLocalRefs(block1, pt, forcedDefined = true) } else errorTree(block, i"local definition of ${leaks.head.name} escapes as part of block's type ${block.tpe}"/*; full type: ${result.tpe.toString}"*/) @@ -542,7 +417,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val cond1 = typed(tree.cond, defn.BooleanType) val thenp1 = typed(tree.thenp, pt) val elsep1 = typed(tree.elsep orElse untpd.unitLiteral withPos tree.pos, pt) - cpy.If(tree, cond1, thenp1, elsep1).withType(thenp1.tpe | elsep1.tpe) + assignType(cpy.If(tree, cond1, thenp1, elsep1), thenp1, elsep1) } def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context) = track("typedFunction") { @@ -649,21 +524,21 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context) = track("typedClosure") { val env1 = tree.env mapconserve (typed(_)) val meth1 = typedUnadapted(tree.meth) - val (ownType, target) = meth1.tpe.widen match { + val target = meth1.tpe.widen match { case mt: MethodType => pt match { case SAMType(meth) if !defn.isFunctionType(pt) && mt <:< meth.info => if (!isFullyDefined(pt, ForceDegree.all)) ctx.error(i"result type of closure is an underspecified SAM type $pt", tree.pos) - (pt, TypeTree(pt)) + TypeTree(pt) case _ => - if (!mt.isDependent) (mt.toFunctionType, EmptyTree) + if (!mt.isDependent) EmptyTree else throw new Error(i"internal error: cannot turn dependent method type $mt into closure, position = ${tree.pos}, raw type = ${mt.toString}") // !!! DEBUG. Eventually, convert to an error? } case tp => throw new Error(i"internal error: closing over non-method $tp, pos = ${tree.pos}") } - cpy.Closure(tree, env1, meth1, target).withType(ownType) + assignType(cpy.Closure(tree, env1, meth1, target), meth1, target) } def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context) = track("typedMatch") { @@ -706,7 +581,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } val guard1 = typedExpr(tree.guard, defn.BooleanType) val body1 = typedExpr(tree.body, pt) - cpy.CaseDef(tree, pat, guard1, body1) withType body1.tpe + assignType(cpy.CaseDef(tree, pat, guard1, body1), body1) } val doCase: () => CaseDef = () => caseRest(typedPattern(tree.pat, selType))(ctx.fresh.withNewScope) @@ -714,7 +589,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } val cases1 = tree.cases mapconserve typedCase - cpy.Match(tree, sel1, cases1).withType(ctx.typeComparer.lub(cases1.tpes)) + assignType(cpy.Match(tree, sel1, cases1), cases1) } } @@ -736,27 +611,25 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } val (from, proto) = enclMethInfo(ctx) val expr1 = typedExpr(tree.expr orElse untpd.unitLiteral.withPos(tree.pos), proto) - cpy.Return(tree, expr1, from) withType defn.NothingType + assignType(cpy.Return(tree, expr1, from)) } def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = track("typedTry") { val expr1 = typed(tree.expr, pt) val handler1 = typed(tree.handler, defn.FunctionType(defn.ThrowableType :: Nil, pt)) val finalizer1 = typed(tree.finalizer, defn.UnitType) - val handlerTypeArgs = handler1.tpe.baseArgTypesHi(defn.FunctionClass(1)) - val ownType = if (handlerTypeArgs.nonEmpty) expr1.tpe | handlerTypeArgs(1) else expr1.tpe - cpy.Try(tree, expr1, handler1, finalizer1) withType ownType + assignType(cpy.Try(tree, expr1, handler1, finalizer1), expr1, handler1) } def typedThrow(tree: untpd.Throw)(implicit ctx: Context): Throw = track("typedThrow") { val expr1 = typed(tree.expr, defn.ThrowableType) - cpy.Throw(tree, expr1) withType defn.NothingType + assignType(cpy.Throw(tree, expr1)) } def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context): SeqLiteral = track("typedSeqLiteral") { val proto1 = pt.elemType orElse WildcardType val elems1 = tree.elems mapconserve (typed(_, proto1)) - cpy.SeqLiteral(tree, elems1) withType defn.SeqType.appliedTo(ctx.typeComparer.lub(elems1.tpes)) + assignType(cpy.SeqLiteral(tree, elems1), elems1) } def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree = track("typedTypeTree") { @@ -770,24 +643,19 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def typedSingletonTypeTree(tree: untpd.SingletonTypeTree)(implicit ctx: Context): SingletonTypeTree = track("typedSingletonTypeTree") { val ref1 = typedExpr(tree.ref) checkStable(ref1.tpe, tree.pos) - cpy.SingletonTypeTree(tree, ref1) withType ref1.tpe - } - - def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): SelectFromTypeTree = track("typedSelectFromTypeTree") { - val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this)) - cpy.SelectFromTypeTree(tree, qual1, tree.name).withType(checkedSelectionType(qual1, tree)) + assignType(cpy.SingletonTypeTree(tree, ref1), ref1) } def typedAndTypeTree(tree: untpd.AndTypeTree)(implicit ctx: Context): AndTypeTree = track("typedAndTypeTree") { val left1 = typed(tree.left) val right1 = typed(tree.right) - cpy.AndTypeTree(tree, left1, right1) withType left1.tpe & right1.tpe + assignType(cpy.AndTypeTree(tree, left1, right1), left1, right1) } def typedOrTypeTree(tree: untpd.OrTypeTree)(implicit ctx: Context): OrTypeTree = track("typedOrTypeTree") { val left1 = typed(tree.left) val right1 = typed(tree.right) - cpy.OrTypeTree(tree, left1, right1) withType left1.tpe | right1.tpe + assignType(cpy.OrTypeTree(tree, left1, right1), left1, right1) } def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(implicit ctx: Context): RefinedTypeTree = track("typedRefinedTypeTree") { @@ -818,16 +686,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def typedAppliedTypeTree(tree: untpd.AppliedTypeTree)(implicit ctx: Context): AppliedTypeTree = track("typedAppliedTypeTree") { val tpt1 = typed(tree.tpt) val args1 = tree.args mapconserve (typed(_)) - val tparams = tpt1.tpe.typeParams - if (args1.length != tparams.length) - ctx.error(i"wrong number of type arguments for ${tpt1.tpe}, should be ${tparams.length}") // todo in later phase: check arguments conform to parameter bounds - cpy.AppliedTypeTree(tree, tpt1, args1) withType tpt1.tpe.appliedTo(args1.tpes) + assignType(cpy.AppliedTypeTree(tree, tpt1, args1), tpt1, args1) } def typedByNameTypeTree(tree: untpd.ByNameTypeTree)(implicit ctx: Context): ByNameTypeTree = track("typedByNameTypeTree") { val result1 = typed(tree.result) - cpy.ByNameTypeTree(tree, result1) withType ExprType(result1.tpe) + assignType(cpy.ByNameTypeTree(tree, result1), result1) } def typedTypeBoundsTree(tree: untpd.TypeBoundsTree)(implicit ctx: Context): TypeBoundsTree = track("typedTypeBoundsTree") { @@ -836,19 +701,19 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val hi1 = typed(hi) if (!(lo1.tpe <:< hi1.tpe)) ctx.error(i"lower bound ${lo1.tpe} does not conform to upper bound ${hi1.tpe}", tree.pos) - cpy.TypeBoundsTree(tree, lo1, hi1) withType TypeBounds(lo1.tpe, hi1.tpe) + assignType(cpy.TypeBoundsTree(tree, lo1, hi1), lo1, hi1) } def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = track("typedBind") { val body1 = typed(tree.body, pt) typr.println(s"typed bind ${tree.show} pt = ${pt.show} bodytpe = ${body1.tpe.show}") val sym = ctx.newSymbol(ctx.owner, tree.name.asTermName, EmptyFlags, body1.tpe, coord = tree.pos) - cpy.Bind(tree, tree.name, body1) withType TermRef(NoPrefix, sym) + assignType(cpy.Bind(tree, tree.name, body1), sym) } def typedAlternative(tree: untpd.Alternative, pt: Type)(implicit ctx: Context): Alternative = track("typedAlternative") { val trees1 = tree.trees mapconserve (typed(_, pt)) - cpy.Alternative(tree, trees1) withType ctx.typeComparer.lub(trees1.tpes) + assignType(cpy.Alternative(tree, trees1), trees1) } def typedModifiers(mods: untpd.Modifiers)(implicit ctx: Context): Modifiers = track("typedModifiers") { @@ -870,8 +735,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit case Ident(nme.WILDCARD) => rhs withType tpt1.tpe case _ => typedExpr(rhs, tpt1.tpe) } - val refType = if (sym.exists) sym.valRef else NoType - cpy.ValDef(vdef, mods1, name, tpt1, rhs1).withType(refType) + assignType(cpy.ValDef(vdef, mods1, name, tpt1, rhs1), sym) } def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = track("typedDefDef") { @@ -885,7 +749,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit } val tpt1 = typedType(tpt) val rhs1 = typedExpr(rhs, tpt1.tpe) - cpy.DefDef(ddef, mods1, name, tparams1, vparamss1, tpt1, rhs1).withType(sym.termRefWithSig) + assignType(cpy.DefDef(ddef, mods1, name, tparams1, vparamss1, tpt1, rhs1), sym) //todo: make sure dependent method types do not depend on implicits or by-name params } @@ -893,7 +757,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit val TypeDef(mods, name, rhs) = tdef val mods1 = typedModifiers(mods) val _ = typedType(rhs) // unused, typecheck only to remove from typedTree - cpy.TypeDef(tdef, mods1, name, TypeTree(sym.info)).withType(sym.typeRef) + assignType(cpy.TypeDef(tdef, mods1, name, TypeTree(sym.info)), sym) } def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = track("typedClassDef") { @@ -928,7 +792,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit checkNoDoubleDefs(cls) val impl1 = cpy.Template(impl, constr1, parents1, self1, body1) .withType(localDummy.termRef) - cpy.TypeDef(cdef, mods1, name, impl1).withType(cls.typeRef) + assignType(cpy.TypeDef(cdef, mods1, name, impl1), cls) // todo later: check that // 1. If class is non-abstract, it is instantiatable: @@ -942,23 +806,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit def typedImport(imp: untpd.Import, sym: Symbol)(implicit ctx: Context): Import = track("typedImport") { val expr1 = typedExpr(imp.expr, AnySelectionProto) checkStable(expr1.tpe, imp.expr.pos) - cpy.Import(imp, expr1, imp.selectors).withType(sym.termRef) - } - - def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = track("typedAnnotated") { - val annot1 = typed(tree.annot, defn.AnnotationClass.typeRef) - val arg1 = typed(tree.arg, pt) - val underlyingType = if (arg1.isTerm) arg1.tpe.widen else arg1.tpe - val ownType = AnnotatedType(Annotation(annot1), underlyingType) - if (ctx.mode is Mode.Type) - cpy.Annotated(tree, annot1, arg1) withType ownType - else - cpy.Typed(tree, arg1, TypeTree(ownType)) withType ownType + assignType(cpy.Import(imp, expr1, imp.selectors), sym) } - def typedAsFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = - typed(tree, if (defn.isFunctionType(pt)) pt else AnyFunctionProto) - def typedPackageDef(tree: untpd.PackageDef)(implicit ctx: Context): Tree = track("typedPackageDef") { val pid1 = typedExpr(tree.pid, AnySelectionProto) val pkg = pid1.symbol @@ -972,6 +822,20 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit cpy.PackageDef(tree, pid1.asInstanceOf[RefTree], stats1) withType pkg.valRef } + def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = track("typedAnnotated") { + val annot1 = typed(tree.annot, defn.AnnotationClass.typeRef) + val arg1 = typed(tree.arg, pt) + if (ctx.mode is Mode.Type) + assignType(cpy.Annotated(tree, annot1, arg1), annot1, arg1) + else { + val tpt = TypeTree(AnnotatedType(Annotation(annot1), arg1.tpe.widen)) + assignType(cpy.Typed(tree, arg1, tpt), tpt) + } + } + + def typedAsFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = + typed(tree, if (defn.isFunctionType(pt)) pt else AnyFunctionProto) + def typedUnadapted(initTree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = { record("typedUnadapted") val xtree = expanded(initTree) -- cgit v1.2.3