Scanners added.

Moving Positions, Chars to new packages.
Added Source positions.
Added untyped trees module.
Factored out behavior between typed and untyped trees.

Author: odersky

src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -66,7 +66,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val logFreeTypes = BooleanSetting("-Xlog-free-types", "Print a message when reification resorts to generating a free type.")
   val maxClassfileName = IntSetting("-Xmax-classfile-name", "Maximum filename length for generated classes", 255, 72 to 255)
   val Xmigration28 = BooleanSetting("-Xmigration", "Warn about constructs whose behavior may have changed between 2.7 and 2.8.")
-  val nouescape = BooleanSetting("-Xno-uescape", "Disable handling of \\u unicode escapes.")
   val Xnojline = BooleanSetting("-Xnojline", "Do not use JLine for editing.")
   val Xverify = BooleanSetting("-Xverify", "Verify generic signatures in generated bytecode (asm backend only.)")
   val plugin = MultiStringSetting("-Xplugin", "file", "Load one or more plugins from files.")

src/dotty/tools/dotc/core/Annotations.scala

@@ -1,6 +1,7 @@
-package dotty.tools.dotc.core
+package dotty.tools.dotc
+package core
 
-import Symbols._, Types._, Positions._, Contexts._, Constants._, TypedTrees.tpd._
+import Symbols._, Types._, util.Positions._, Contexts._, Constants._, TypedTrees.tpd._
 
 object Annotations {
 

src/dotty/tools/dotc/core/Contexts.scala

@@ -8,8 +8,8 @@ import Names._
 import Phases._
 import Types._
 import Symbols._
-import TypeComparers._, Printers._, NameOps._, SymDenotations._, Positions._
-import TypedTrees.tpd._
+import TypeComparers._, Printers._, NameOps._, SymDenotations._, util.Positions._
+import TypedTrees.tpd._, util.FreshNameCreator
 import config.Settings._
 import config.ScalaSettings
 import reporting._
@@ -172,7 +172,7 @@ object Contexts {
     /** The current source file; will be derived from current
      *  compilation unit.
      */
-    def source = io.NoSource // for now
+    def source = util.NoSource // for now
 
     /** Does current phase use an erased types interpretation? */
     def erasedTypes: Boolean = phase.erasedTypes
@@ -289,6 +289,9 @@ object Contexts {
     /** The platform */
     val platform: Platform = new JavaPlatform
 
+    /** The standard fresh name creator */
+    val fresh = new FreshNameCreator.Default
+
     /** The loader that loads the members of _root_ */
     def rootLoader(root: TermSymbol)(implicit ctx: Context): SymbolLoader = platform.rootLoader(root)
 

src/dotty/tools/dotc/core/Definitions.scala

@@ -3,7 +3,7 @@ package dotc
 package core
 
 import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._, Positions._
+import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._
 import scala.annotation.{ switch, meta }
 import scala.collection.{ mutable, immutable }
 import PartialFunction._

src/dotty/tools/dotc/core/NameOps.scala

@@ -2,11 +2,12 @@ package dotty.tools.dotc
 package core
 
 import java.security.MessageDigest
-import Chars.isOperatorPart
 import scala.annotation.switch
 import scala.io.Codec
 import Names._, StdNames._, Contexts._, Symbols._, Flags._
 import Decorators.StringDecorator
+import dotty.tools.dotc.util.Chars
+import Chars.isOperatorPart
 
 object NameOps {
 

src/dotty/tools/dotc/core/StdNames.scala

@@ -240,7 +240,6 @@ object StdNames {
     val SETTER_SUFFIX: N            = encode("_=")
     val SKOLEM: N                   = "<skolem>"
     val SPECIALIZED_INSTANCE: N     = "specInstance$"
-    val STAR: N                     = "*"
     val THIS: N                     = "_$this"
     val HK_PARAM_PREFIX: N          = "_$hk$"
 

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -577,6 +577,12 @@ object SymDenotations {
     final def symbolicRef(implicit ctx: Context): TypeRef =
       TypeRef.withSym(owner.thisType, symbol.asType)
 
+    /** The termref pointing to this termsymbol
+     *  @throws ClassCastException is this is not a term
+     */
+    def termRef(implicit ctx: Context): TermRef =
+      TermRef.withSym(owner.thisType, symbol.asTerm)
+
     /** The variance of this type parameter as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter
      */

src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -10,7 +10,7 @@ package core
 import java.io.IOException
 import scala.compat.Platform.currentTime
 import dotty.tools.io.{ ClassPath, AbstractFile }
-import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Positions._, Names._
+import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, util.Positions._, Names._
 import StdNames._
 import Decorators.StringDecorator
 import pickling.ClassfileParser

src/dotty/tools/dotc/core/Symbols.scala

@@ -11,7 +11,7 @@ import Decorators._
 import Symbols._
 import Contexts._
 import SymDenotations._, util.Texts._
-import Types._, Annotations._, Positions._, StdNames._, Trees._, NameOps._
+import Types._, Annotations._, util.Positions._, StdNames._, Trees._, NameOps._
 import Denotations.{ Denotation, SingleDenotation, MultiDenotation }
 import collection.mutable
 import io.AbstractFile

src/dotty/tools/dotc/core/Trees.scala

@@ -1,6 +1,7 @@
-package dotty.tools.dotc.core
+package dotty.tools.dotc
+package core
 
-import Types._, Names._, Flags._, Positions._, Contexts._, Constants._, SymDenotations._, Symbols._
+import Types._, Names._, Flags._, util.Positions._, Contexts._, Constants._, SymDenotations._, Symbols._
 import Denotations._, StdNames._
 import annotation.tailrec
 import language.higherKinds
@@ -110,6 +111,7 @@ object Trees {
     override def getMessage: String = s"type of $tree is not assigned"
   }
 
+  type Untyped = Null
   type TypedTree = Tree[Type]
   type UntypedTree = Tree[Nothing]
 
@@ -532,6 +534,9 @@ object Trees {
     extends NameTree[Nothing] with DefTree[Nothing] {
     type ThisTree[T] <: NameTree[T] with DefTree[T] with ModuleDef
     val pos = cpos union impl.pos
+    def derivedModuleDef(mods: Modifiers[Nothing], name: TermName, impl: Template[Nothing]) =
+      if (mods == this.mods && name == this.name && (impl eq this.impl)) this
+      else ModuleDef(mods, name, impl)
   }
 
   /** (vparams) => body */
@@ -541,6 +546,78 @@ object Trees {
     val pos = unionPos(cpos union body.pos, vparams)
   }
 
+  /** Something in parentheses */
+  case class Parens(trees: List[Tree[Nothing]])(implicit cpos: Position) extends Tree[Nothing] {
+    type ThisType[T] <: Parens
+    val pos = unionPos(cpos, trees)
+  }
+
+  // ----- Generic Tree Instances, inherited from  `tpt` and `untpd`.
+
+  abstract class Instance[T] {
+
+    type Modifiers = Trees.Modifiers[T]
+    type Tree = Trees.Tree[T]
+    type TypTree = Trees.TypTree[T]
+    type TermTree = Trees.TermTree[T]
+    type PatternTree = Trees.PatternTree[T]
+    type DenotingTree = Trees.DenotingTree[T]
+    type ProxyTree = Trees.ProxyTree[T]
+    type NameTree = Trees.NameTree[T]
+    type RefTree = Trees.RefTree[T]
+    type DefTree = Trees.DefTree[T]
+
+    type TreeCopier = Trees.TreeCopier[T]
+    type TreeAccumulator[U] = Trees.TreeAccumulator[U, T]
+    type TreeTransformer = Trees.TreeTransformer[T]
+
+    type Ident = Trees.Ident[T]
+    type Select = Trees.Select[T]
+    type This = Trees.This[T]
+    type Super = Trees.Super[T]
+    type Apply = Trees.Apply[T]
+    type TypeApply = Trees.TypeApply[T]
+    type Literal = Trees.Literal[T]
+    type New = Trees.New[T]
+    type Pair = Trees.Pair[T]
+    type Typed = Trees.Typed[T]
+    type NamedArg = Trees.NamedArg[T]
+    type Assign = Trees.Assign[T]
+    type Block = Trees.Block[T]
+    type If = Trees.If[T]
+    type Match = Trees.Match[T]
+    type CaseDef = Trees.CaseDef[T]
+    type Return = Trees.Return[T]
+    type Try = Trees.Try[T]
+    type Throw = Trees.Throw[T]
+    type SeqLiteral = Trees.SeqLiteral[T]
+    type TypeTree = Trees.TypeTree[T]
+    type SingletonTypeTree = Trees.SingletonTypeTree[T]
+    type SelectFromTypeTree = Trees.SelectFromTypeTree[T]
+    type AndTypeTree = Trees.AndTypeTree[T]
+    type OrTypeTree = Trees.OrTypeTree[T]
+    type RefineTypeTree = Trees.RefineTypeTree[T]
+    type AppliedTypeTree = Trees.AppliedTypeTree[T]
+    type TypeBoundsTree = Trees.TypeBoundsTree[T]
+    type Bind = Trees.Bind[T]
+    type Alternative = Trees.Alternative[T]
+    type UnApply = Trees.UnApply[T]
+    type ValDef = Trees.ValDef[T]
+    type DefDef = Trees.DefDef[T]
+    type TypeDef = Trees.TypeDef[T]
+    type Template = Trees.Template[T]
+    type ClassDef = Trees.ClassDef[T]
+    type Import = Trees.Import[T]
+    type PackageDef = Trees.PackageDef[T]
+    type Annotated = Trees.Annotated[T]
+    type EmptyTree = Trees.EmptyTree[T]
+    type SharedTree = Trees.SharedTree[T]
+
+    protected implicit def pos(implicit ctx: Context): Position = ctx.position
+
+    def defPos(sym: Symbol)(implicit ctx: Context) = ctx.position union sym.coord.toPosition
+  }
+
   // ----- Helper functions and classes ---------------------------------------
 
   @tailrec final def unionPos(base: Position, trees: List[Tree[_]]): Position = trees match {
@@ -712,7 +789,7 @@ object Trees {
     }
   }
 
-  abstract class TreeTransformer[T, C] {
+  abstract class FullTreeTransformer[T, C] {
     var sharedMemo: Map[SharedTree[T], SharedTree[T]] = Map()
 
     def transform(tree: Tree[T], c: C): Tree[T] = tree match {
@@ -861,6 +938,107 @@ object Trees {
     def finishSharedTree(tree: Tree[T], old: Tree[T], c: C, plugins: Plugins) = tree
   }
 
+  abstract class TreeTransformer[T] {
+    var sharedMemo: Map[SharedTree[T], SharedTree[T]] = Map()
+
+    def transform(tree: Tree[T]): Tree[T] = tree match {
+      case Ident(name) =>
+        tree
+      case Select(qualifier, name) =>
+        tree.derivedSelect(transform(qualifier), name)
+      case This(qual) =>
+        tree
+      case Super(qual, mix) =>
+        tree.derivedSuper(transform(qual), mix)
+      case Apply(fun, args) =>
+        tree.derivedApply(transform(fun), transform(args))
+      case TypeApply(fun, args) =>
+        tree.derivedTypeApply(transform(fun), transform(args))
+      case Literal(const) =>
+        tree
+      case New(tpt) =>
+        tree.derivedNew(transform(tpt))
+      case Pair(left, right) =>
+        tree.derivedPair(transform(left), transform(right))
+      case Typed(expr, tpt) =>
+        tree.derivedTyped(transform(expr), transform(tpt))
+      case NamedArg(name, arg) =>
+        tree.derivedNamedArg(name, transform(arg))
+      case Assign(lhs, rhs) =>
+        tree.derivedAssign(transform(lhs), transform(rhs))
+      case Block(stats, expr) =>
+        tree.derivedBlock(transform(stats), transform(expr))
+      case If(cond, thenp, elsep) =>
+        tree.derivedIf(transform(cond), transform(thenp), transform(elsep))
+      case Match(selector, cases) =>
+        tree.derivedMatch(transform(selector), transformSub(cases))
+      case CaseDef(pat, guard, body) =>
+        tree.derivedCaseDef(transform(pat), transform(guard), transform(body))
+      case Return(expr, from) =>
+        tree.derivedReturn(transform(expr), transformSub(from))
+      case Try(block, catches, finalizer) =>
+        tree.derivedTry(transform(block), transformSub(catches), transform(finalizer))
+      case Throw(expr) =>
+        tree.derivedThrow(transform(expr))
+      case SeqLiteral(elemtpt, elems) =>
+        tree.derivedSeqLiteral(transform(elemtpt), transform(elems))
+      case TypeTree(original) =>
+        tree.derivedTypeTree(transform(original))
+      case SingletonTypeTree(ref) =>
+        tree.derivedSingletonTypeTree(transform(ref))
+      case SelectFromTypeTree(qualifier, name) =>
+        tree.derivedSelectFromTypeTree(transform(qualifier), name)
+      case AndTypeTree(left, right) =>
+        tree.derivedAndTypeTree(transform(left), transform(right))
+      case OrTypeTree(left, right) =>
+        tree.derivedOrTypeTree(transform(left), transform(right))
+      case RefineTypeTree(tpt, refinements) =>
+        tree.derivedRefineTypeTree(transform(tpt), transformSub(refinements))
+      case AppliedTypeTree(tpt, args) =>
+        tree.derivedAppliedTypeTree(transform(tpt), transform(args))
+      case TypeBoundsTree(lo, hi) =>
+        tree.derivedTypeBoundsTree(transform(lo), transform(hi))
+      case Bind(name, body) =>
+        tree.derivedBind(name, transform(body))
+      case Alternative(trees) =>
+        tree.derivedAlternative(transform(trees))
+      case UnApply(fun, args) =>
+        tree.derivedUnApply(transform(fun), transform(args))
+      case ValDef(mods, name, tpt, rhs) =>
+        tree.derivedValDef(mods, name, transform(tpt), transform(rhs))
+      case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
+        tree.derivedDefDef(mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt), transform(rhs))
+      case TypeDef(mods, name, rhs) =>
+        tree.derivedTypeDef(mods, name, transform(rhs))
+      case Template(parents, self, body) =>
+        tree.derivedTemplate(transform(parents), transformSub(self), transform(body))
+      case ClassDef(mods, name, tparams, impl) =>
+        tree.derivedClassDef(mods, name, transformSub(tparams), transformSub(impl))
+      case Import(expr, selectors) =>
+        tree.derivedImport(transform(expr), selectors)
+      case PackageDef(pid, stats) =>
+        tree.derivedPackageDef(transformSub(pid), transform(stats))
+      case Annotated(annot, arg) =>
+        tree.derivedAnnotated(transform(annot), transform(arg))
+      case EmptyTree() =>
+        tree
+      case tree @ SharedTree(shared) =>
+        sharedMemo get tree match {
+          case Some(tree1) => tree1
+          case None =>
+            val tree1 = tree.derivedSharedTree(transform(shared))
+            sharedMemo = sharedMemo.updated(tree, tree1)
+            tree1
+        }
+    }
+    def transform(trees: List[Tree[T]]): List[Tree[T]] =
+      trees mapConserve (transform(_))
+    def transformSub(tree: Tree[T]): tree.ThisTree[T] =
+      transform(tree).asInstanceOf[tree.ThisTree[T]]
+    def transformSub[TT <: Tree[T]](trees: List[TT]): List[TT] =
+      transform(trees).asInstanceOf[List[TT]]
+  }
+
   abstract class TreeAccumulator[T, U] extends ((T, Tree[U]) => T) {
     var sharedMemo: Map[SharedTree[U], T] = Map()
     def apply(x: T, tree: Tree[U]): T