path: root/src/dotty/tools/dotc/typer/Typer.scala

package dotty.tools
package dotc
package typer

import core._
import ast._
import Trees._, Constants._, StdNames._, Scopes._
import Contexts._, Symbols._, Types._, SymDenotations._, Names._, NameOps._, Flags._, Decorators._
import util.Positions._
import util.SourcePosition
import collection.mutable
import language.implicitConversions
import desugar.Mode

trait TyperContextOps { ctx: Context => }


class Typer extends Namer {

  import tpd._

  def typedImport(imp: untpd.Import, pt: Type)(implicit ctx: Context): Import = {
    val expr1 = typed(imp.expr)
    imp.withType(pt).derivedImport(expr1, imp.selectors)
  }

  def typedModifiers(mods: untpd.Modifiers): Modifiers = ???

  def typedValDef(defn: untpd.ValDef, sym: Symbol)(implicit ctx: Context) = {
    val Trees.ValDef(mods, name, tpt, rhs) = defn
    val mods1 = typedModifiers(mods)
    val tpt1 = typedType(tpt)
    val rhs1 = typedExpr(rhs, tpt1.tpe)
    val pt = if (sym.exists) sym.symRef else NoType
    defn.withType(pt).derivedValDef(mods1, name, tpt1, rhs1)
  }

  def typedDefDef(defn: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = {
    val Trees.DefDef(mods, name, tparams, vparamss, tpt, rhs) = defn
    val mods1 = typedModifiers(mods)
    val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
    val vparamss1 = vparamss.mapconserve(_ mapconserve (typed(_).asInstanceOf[ValDef]))
    val tpt1 = typedType(tpt)
    val rhs1 = typedExpr(rhs, tpt1.tpe)
    defn.withType(sym.symRef).derivedDefDef(mods1, name, tparams1, vparamss1, tpt1, rhs1)
  }

  def typedTypeDef(defn: untpd.TypeDef, sym: Symbol)(implicit ctx: Context): TypeDef = {
    val Trees.TypeDef(mods, name, tparams, rhs) = defn
    val mods1 = typedModifiers(mods)
    val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
    val rhs1 = typedType(rhs)
    defn.withType(sym.symRef).derivedTypeDef(mods1, name, tparams1, rhs1)
  }

  def typedClassDef(defn: untpd.ClassDef, cls: ClassSymbol)(implicit ctx: Context) = {
    val Trees.ClassDef(mods, name, impl @ Trees.Template(constr, parents, self, body)) = defn
    val mods1 = typedModifiers(mods)
    val constr1 = typed(constr)
    val parents1 = parents mapconserve (typed(_))
    val self1 = typed(self)
    ???
  }

  def typedMemberDef(defn: untpd.MemberDef, sym: Symbol)(implicit ctx: Context) = {
    sym.ensureCompleted()
    def localContext = ctx.fresh.withOwner(sym)
    defn match {
      case defn: untpd.ValDef =>
        typedValDef(defn, sym)(localContext)
      case defn: untpd.DefDef =>
        val typer1 = nestedTyper.remove(sym).get
        typer1.typedDefDef(defn, sym)(localContext.withScope(typer1.scope))
      case defn: untpd.TypeDef =>
        typedTypeDef(defn, sym)(localContext.withNewScope)
      case defn: untpd.ClassDef =>
        typedClassDef(defn, sym.asClass)(localContext)
    }
  }

  def typed(tree: untpd.Tree, mode: Mode.Value = Mode.Expr, pt: Type = WildcardType)(implicit ctx: Context): Tree = {
    typedTree get tree match {
      case Some(tree1) => tree1
      case none => tree match {
        case defn: untpd.MemberDef =>
          typedMemberDef(defn, symOfTree(defn))
        case imp: untpd.Import =>
          typedImport(imp, symOfTree(imp).symRef)
        case tree: untpd.TypeTree =>
          if (!tree.isEmpty) typed(tree.original, Mode.Type, pt)
          else {
            assert(pt != WildcardType)
            tree.withType(pt)
          }
        case untpd.EmptyTree =>
          tpd.EmptyTree
      }
    }
  }

  def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
    typed(tree, Mode.Expr, pt)
  def typedType(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
    typed(tree, Mode.Type, pt)

}