Refine avoiding local refs in block's type.

If all else fails, force all type variables with fullyDefinedType. This can avoid references to locals. Example in file dotctest: SourceFile.scala, method calculateLineIndices.

1 files changed, 102 insertions, 494 deletions

diff --git a/tests/pos/dotctest.scala b/tests/pos/dotctest.scala
index 93456dac9..4e1eb224a 100644
--- a/tests/pos/dotctest.scala
+++ b/tests/pos/dotctest.scala
@@ -1,527 +1,135 @@
 package dotty.tools
 package dotc
-package core
-
-import Periods._
-import Transformers._
-import Names._, Scopes._
-import Flags._
-import java.lang.AssertionError
-import Decorators._
-import Symbols._
-import Contexts._
-import SymDenotations._ 
-import printing.Texts._
-import printing.Printer
-import Types._, Annotations._, util.Positions._, StdNames._, NameOps._
-import ast.tpd.{TreeMapper, SharedTree}
-import Denotations.{ Denotation, SingleDenotation, MultiDenotation }
-import collection.mutable
-import io.AbstractFile
-import language.implicitConversions
-
-/** Creation methods for symbols */
-trait Symbols { this: Context =>
-  
-  // import Symbols._
-
-// ---- Factory methods for symbol creation ----------------------
-//
-// All symbol creations should be done via the next two methods.
-
-  /** Create a symbol without a denotation.
-   *  Note this uses a cast instead of a direct type refinement because
-   *  it's debug-friendlier not to create an anonymous class here.
-   */
-  def newNakedSymbol[N <: Name](coord: Coord = NoCoord): Symbol { type ThisName = N } =
-    new Symbol(coord).asInstanceOf[Symbol { type ThisName = N }]
-
-  /** Create a class symbol without a denotation. */
-  def newNakedClassSymbol(coord: Coord = NoCoord, assocFile: AbstractFile = null) =
-    new ClassSymbol(coord, assocFile)
-
-// ---- Symbol creation methods ----------------------------------
-
-  /** Create a symbol from a function producing its denotation */
-  def newSymbolDenoting[N <: Name](denotFn: Symbol => SymDenotation, coord: Coord = NoCoord): Symbol { type ThisName = N } = {
-    val sym = newNakedSymbol[N](coord)
-    sym.denot = denotFn(sym)
-    sym
-  }
-
-  /** Create a symbol from its fields (info may be lazy) */
-  def newSymbol[N <: Name](
-      owner: Symbol,
-      name: N,
-      flags: FlagSet,
-      info: Type,
-      privateWithin: Symbol = NoSymbol,
-      coord: Coord = NoCoord): Symbol { type ThisName = N } = {
-    val sym = newNakedSymbol[N](coord)
-    val denot = SymDenotation(sym, owner, name, flags, info, privateWithin)
-    sym.denot = denot
-    sym
-  }
-
-  /** Create a class symbol from a function producing its denotation */
-  def newClassSymbolDenoting(denotFn: ClassSymbol => SymDenotation, coord: Coord = NoCoord, assocFile: AbstractFile = null): ClassSymbol = {
-    val cls = newNakedClassSymbol(coord, assocFile)
-    cls.denot = denotFn(cls)
-    cls
-  }
-
-  /** Create a class symbol from its non-info fields and a function
-   *  producing its info (the produced info may be lazy).
-   */
-  def newClassSymbol(
-      owner: Symbol,
-      name: TypeName,
-      flags: FlagSet,
-      infoFn: ClassSymbol => Type,
-      privateWithin: Symbol = NoSymbol,
-      coord: Coord = NoCoord,
-      assocFile: AbstractFile = null): ClassSymbol
-  = {
-    val cls = newNakedClassSymbol(coord, assocFile)
-    val denot = SymDenotation(cls, owner, name, flags, infoFn(cls), privateWithin)
-    cls.denot = denot
-    cls
-  }
-
-  /** Create a class symbol from its non-info fields and the fields of its info. */
-  def newCompleteClassSymbol(
-      owner: Symbol,
-      name: TypeName,
-      flags: FlagSet,
-      parents: List[TypeRef],
-      decls: Scope = newScope,
-      selfInfo: Type = NoType,
-      privateWithin: Symbol = NoSymbol,
-      coord: Coord = NoCoord,
-      assocFile: AbstractFile = null): ClassSymbol =
-    newClassSymbol(
-        owner, name, flags,
-        ClassInfo(owner.thisType, _, parents, decls, selfInfo),
-        privateWithin, coord, assocFile)
-
-  /** Create a module symbol with associated module class
-   *  from its non-info fields and a function producing the info
-   *  of the module class (this info may be lazy).
-   */
-  def newModuleSymbol(
-      owner: Symbol,
-      name: TermName,
-      modFlags: FlagSet,
-      clsFlags: FlagSet,
-      infoFn: (TermSymbol, ClassSymbol) => Type, // typically a ModuleClassCompleterWithDecls
-      privateWithin: Symbol = NoSymbol,
-      coord: Coord = NoCoord,
-      assocFile: AbstractFile = null): TermSymbol
-  = {
-    val base = owner.thisType
-    val module = newNakedSymbol[TermName](coord)
-    val modcls = newNakedClassSymbol(coord, assocFile)
-    val modclsFlags = clsFlags | ModuleClassCreationFlags
-    val modclsName = name.toTypeName.adjustIfModuleClass(modclsFlags)
-    val cdenot = SymDenotation(
-        modcls, owner, modclsName, modclsFlags,
-        infoFn(module, modcls), privateWithin)
-    val mdenot = SymDenotation(
-        module, owner, name, modFlags | ModuleCreationFlags,
-        if (cdenot.isCompleted) TypeRef(owner.thisType, modclsName) withSym modcls
-        else new ModuleCompleter(modcls)(condensed))
-    module.denot = mdenot
-    modcls.denot = cdenot
-    module
-  }
-
-  /** Create a module symbol with associated module class
-   *  from its non-info fields and the fields of the module class info.
-   *  @param flags  The combined flags of the module and the module class
-   *                These are masked with RetainedModuleValFlags/RetainedModuleClassFlags.
-   */
-  def newCompleteModuleSymbol(
-      owner: Symbol,
-      name: TermName,
-      modFlags: FlagSet,
-      clsFlags: FlagSet,
-      parents: List[TypeRef],
-      decls: Scope,
-      privateWithin: Symbol = NoSymbol,
-      coord: Coord = NoCoord,
-      assocFile: AbstractFile = null): TermSymbol =
-    newModuleSymbol(
-        owner, name, modFlags, clsFlags,
-        (module, modcls) => ClassInfo(
-          owner.thisType, modcls, parents, decls, TermRef(owner.thisType, name) withSym module),
-        privateWithin, coord, assocFile)
-
-  /** Create a package symbol with associated package class
-   *  from its non-info fields and a lazy type for loading the package's members.
-   */
-  def newPackageSymbol(
-      owner: Symbol,
-      name: TermName,
-      infoFn: (TermSymbol, ClassSymbol) => LazyType): TermSymbol =
-    newModuleSymbol(owner, name, PackageCreationFlags, PackageCreationFlags, infoFn)
-
-  /** Create a package symbol with associated package class
-   *  from its non-info fields its member scope.
-   */
-  def newCompletePackageSymbol(
-      owner: Symbol,
-      name: TermName,
-      modFlags: FlagSet = EmptyFlags,
-      clsFlags: FlagSet = EmptyFlags,
-      decls: Scope = newScope): TermSymbol =
-    newCompleteModuleSymbol(
-      owner, name,
-      modFlags | PackageCreationFlags, clsFlags | PackageCreationFlags,
-      Nil, decls)
-
-
-  /** Create a stub symbol that will issue a missing reference error
-   *  when attempted to be completed.
-   */
-  def newStubSymbol(owner: Symbol, name: Name, file: AbstractFile = null): Symbol = {
-    def stubCompleter = new StubInfo()(condensed)
-    val normalizedOwner = if (owner is ModuleVal) owner.moduleClass else owner
-    println(s"creating stub for ${name.show}, owner = ${normalizedOwner.denot.debugString}, file = $file")
-    println(s"decls = ${normalizedOwner.decls.toList.map(_.debugString).mkString("\n  ")}") // !!! DEBUG
-    if (base.settings.debug.value) throw new Error()
-    val stub = name match {
-      case name: TermName =>
-        newModuleSymbol(normalizedOwner, name, EmptyFlags, EmptyFlags, stubCompleter, assocFile = file)
-      case name: TypeName =>
-        newClassSymbol(normalizedOwner, name, EmptyFlags, stubCompleter, assocFile = file)
+package util
+
+import scala.collection.mutable.ArrayBuffer
+import dotty.tools.io._
+import annotation.tailrec
+import java.util.regex.Pattern
+import java.io.IOException
+import Chars._
+import ScriptSourceFile._
+import Positions._
+
+object ScriptSourceFile {
+  private val headerPattern = Pattern.compile("""^(::)?!#.*(\r|\n|\r\n)""", Pattern.MULTILINE)
+  private val headerStarts  = List("#!", "::#!")
+
+  def apply(file: AbstractFile, content: Array[Char]) = {
+    /** Length of the script header from the given content, if there is one.
+     *  The header begins with "#!" or "::#!" and ends with a line starting
+     *  with "!#" or "::!#".
+     */
+    val headerLength =
+      if (headerStarts exists (content startsWith _)) {
+        val matcher = headerPattern matcher content.mkString
+        if (matcher.find) matcher.end
+        else throw new IOException("script file does not close its header with !# or ::!#")
+      } else 0
+    new SourceFile(file, content drop headerLength) {
+      override val underlying = new SourceFile(file, content)
     }
-    stubs = stub :: stubs
-    stub
   }
+}
 
-  /** Create the local template dummy of given class `cls`. */
-  def newLocalDummy(cls: Symbol, coord: Coord = NoCoord) =
-    newSymbol(cls, nme.localDummyName(cls), EmptyFlags, NoType)
-
-  /** Create an import symbol pointing back to given qualifier `expr`. */
-  def newImportSymbol(expr: SharedTree, coord: Coord = NoCoord) =
-    newSymbol(NoSymbol, nme.IMPORT, EmptyFlags, ImportType(expr), coord = coord)
-
-  /** Create a class constructor symbol for given class `cls`. */
-  def newConstructor(cls: ClassSymbol, flags: FlagSet, paramNames: List[TermName], paramTypes: List[Type], privateWithin: Symbol = NoSymbol, coord: Coord = NoCoord) =
-    newSymbol(cls, nme.CONSTRUCTOR, flags | Method, MethodType(paramNames, paramTypes)(_ => cls.typeRef), privateWithin, coord)
-
-  /** Create an empty default constructor symbol for given class `cls`. */
-  def newDefaultConstructor(cls: ClassSymbol) =
-    newConstructor(cls, EmptyFlags, Nil, Nil)
+case class SourceFile(file: AbstractFile, content: Array[Char]) {
 
-  /** Create a symbol representing a selftype declaration for class `cls`. */
-  def newSelfSym(cls: ClassSymbol, name: TermName = nme.WILDCARD, selfInfo: Type = NoType): TermSymbol =
-    ctx.newSymbol(cls, name, SelfSymFlags, selfInfo orElse cls.classInfo.selfType, coord = cls.coord)
+  def this(_file: AbstractFile)                 = this(_file, _file.toCharArray)
+  def this(sourceName: String, cs: Seq[Char])   = this(new VirtualFile(sourceName), cs.toArray)
+  def this(file: AbstractFile, cs: Seq[Char])   = this(file, cs.toArray)
 
-  /** Create new type parameters with given owner, names, and flags.
-   *  @param boundsFn  A function that, given type refs to the newly created
-   *                   parameters returns a list of their bounds.
-   */
-  def newTypeParams(
-    owner: Symbol,
-    names: List[TypeName],
-    flags: FlagSet,
-    boundsFn: List[TypeRef] => List[Type]): List[TypeSymbol] = {
+  /** Tab increment; can be overridden */
+  def tabInc = 8
 
-    val tparamBuf = new mutable.ListBuffer[TypeSymbol]
-    val trefBuf = new mutable.ListBuffer[TypeRef]
-    for (name <- names) {
-      val tparam = newNakedSymbol[TypeName](NoCoord)
-      tparamBuf += tparam
-      trefBuf += TypeRef(owner.thisType, name) withSym tparam
-    }
-    val tparams = tparamBuf.toList
-    val bounds = boundsFn(trefBuf.toList)
-    for ((name, tparam, bound) <- (names, tparams, bounds).zipped)
-      tparam.denot = SymDenotation(tparam, owner, name, flags | TypeParamCreationFlags, bound)
-    tparams
+  override def equals(that : Any) = that match {
+    case that : SourceFile => file.path == that.file.path && start == that.start
+    case _ => false
   }
+  override def hashCode = file.path.## + start.##
 
-  def newSkolem(tp: Type) = newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact, tp)
-
-  def newErrorSymbol(owner: Symbol, name: Name) =
-    newSymbol(owner, name, SyntheticArtifact,
-      if (name.isTypeName) TypeAlias(ErrorType) else ErrorType)
+  def apply(idx: Int) = content.apply(idx)
 
-  type OwnerMap = Symbol => Symbol
+  val length = content.length
 
-  /** Map given symbols, subjecting all types to given type map and owner map.
-   *  Cross symbol references are brought over from originals to copies.
-   *  Do not copy any symbols if all attributes of all symbols stay the same.
-   */
-  def mapSymbols(
-      originals: List[Symbol],
-      typeMap: TypeMap = IdentityTypeMap,
-      ownerMap: OwnerMap = identity)
-  =
-    if (originals forall (sym =>
-        (typeMap(sym.info) eq sym.info) && (ownerMap(sym.owner) eq sym.owner)))
-      originals
-    else {
-      val copies: List[Symbol] = for (original <- originals) yield
-        newNakedSymbol[original.ThisName](original.coord)
-      val treeMap = new TreeMapper(typeMap, ownerMap)
-        .withSubstitution(originals, copies)
-      (originals, copies).zipped foreach {(original, copy) =>
-        val odenot = original.denot
-        copy.denot = odenot.copySymDenotation(
-          symbol = copy,
-          owner = treeMap.ownerMap(odenot.owner),
-          info = treeMap.typeMap(odenot.info),
-          privateWithin = ownerMap(odenot.privateWithin), // since this refers to outer symbols, need not include copies (from->to) in ownermap here.
-          annotations = odenot.annotations.mapConserve(treeMap.apply))
-      }
-      copies
-    }
-
-// ----- Locating predefined symbols ----------------------------------------
-
-  def requiredPackage(path: PreName): TermSymbol =
-    base.staticRef(path.toTermName).requiredSymbol(_ is Package).asTerm
-
-  def requiredClass(path: PreName): ClassSymbol =
-    base.staticRef(path.toTypeName).requiredSymbol(_.isClass).asClass
-
-  def requiredModule(path: PreName): TermSymbol =
-    base.staticRef(path.toTermName).requiredSymbol(_ is Module).asTerm
+  /** true for all source files except `NoSource` */
+  def exists: Boolean = true
 
-  def requiredMethod(cls: ClassSymbol, name: PreName): TermSymbol =
-    cls.info.member(name.toTermName).requiredSymbol(_ is Method).asTerm
-}
+  /** The underlying source file */
+  def underlying: SourceFile = this
 
-object Symbols {
+  /** The start of this file in the underlying source file */
+  def start = 0
 
-  var _nextId = 0 // !!! DEBUG, use global counter instead
-  def nextId = { _nextId += 1; _nextId }
+  def atPos(pos: Position): SourcePosition =
+    if (pos.exists) SourcePosition(underlying, pos)
+    else NoSourcePosition
 
+  def isSelfContained = underlying eq this
 
-  /** A Symbol represents a Scala definition/declaration or a package.
+  /** Map a position to a position in the underlying source file.
+   *  For regular source files, simply return the argument.
    */
-  class Symbol private[Symbols] (val coord: Coord) extends DotClass with printing.Showable {
-
-    type ThisName <: Name
-
-    private[this] var _id: Int = nextId
-    //assert(_id != 5859)
-
-    /** The unique id of this symbol */
-    def id = _id
-
-    /** The last denotation of this symbol */
-    private[this] var lastDenot: SymDenotation = _
-
-    /** Set the denotation of this symbol */
-    private[Symbols] def denot_=(d: SymDenotation) =
-      lastDenot = d
-
-    /** The current denotation of this symbol */
-    final def denot(implicit ctx: Context): SymDenotation = {
-      var denot = lastDenot
-      if (!(denot.validFor contains ctx.period))
-        denot = denot.current.asInstanceOf[SymDenotation]
-      denot
-    }
-
-    private def defRunId: RunId =
-      if (lastDenot == null) NoRunId else lastDenot.validFor.runId
-
-    /** Does this symbol come from a currently compiled source file? */
-    final def isDefinedInCurrentRun(implicit ctx: Context): Boolean = {
-      pos.exists && defRunId == ctx.runId
+  def positionInUltimateSource(position: SourcePosition): SourcePosition =
+    SourcePosition(underlying, position.pos shift start)
+
+  def isLineBreak(idx: Int) =
+    if (idx >= length) false else {
+      val ch = content(idx)
+      // don't identify the CR in CR LF as a line break, since LF will do.
+      if (ch == CR) (idx + 1 == length) || (content(idx + 1) != LF)
+      else isLineBreakChar(ch)
     }
 
-    /** Subclass tests and casts */
-    final def isTerm(implicit ctx: Context): Boolean = denot.isTerm
-    final def isType(implicit ctx: Context): Boolean = denot.isType
-    final def isClass: Boolean = isInstanceOf[ClassSymbol]
-
-    final def asTerm(implicit ctx: Context): TermSymbol = { assert(isTerm, this); asInstanceOf[TermSymbol] }
-    final def asType(implicit ctx: Context): TypeSymbol = { assert(isType, this); asInstanceOf[TypeSymbol] }
-    final def asClass: ClassSymbol = asInstanceOf[ClassSymbol]
-
-    /** A unique, densely packed integer tag for each class symbol, -1
-     *  for all other symbols. To save memory, this method
-     *  should be called only if class is a super class of some other class.
-     */
-    def superId(implicit ctx: Context): Int = -1
-
-    /** This symbol entered into owner's scope (owner must be a class). */
-    final def entered(implicit ctx: Context): this.type = {
-      assert(this.owner.isClass, this.owner.denot) // !!! DEBUG
-      this.owner.asClass.enter(this)
-      if (this is Module) this.owner.asClass.enter(this.moduleClass)
-      this
-    }
-
-    /** This symbol, if it exists, otherwise the result of evaluating `that` */
-    def orElse(that: => Symbol)(implicit ctx: Context) =
-      if (this.exists) this else that
-
-    /** If this symbol satisfies predicate `p` this symbol, otherwise `NoSymbol` */
-    def filter(p: Symbol => Boolean): Symbol = if (p(this)) this else NoSymbol
-
-    /** Is symbol a primitive value class? */
-    def isPrimitiveValueClass(implicit ctx: Context) = defn.ScalaValueClasses contains this
-
-    /** Is symbol a phantom class for which no runtime representation exists? */
-    def isPhantomClass(implicit ctx: Context) = defn.PhantomClasses contains this
-
-    /** The current name of this symbol */
-    final def name(implicit ctx: Context): ThisName = denot.name.asInstanceOf[ThisName]
-
-    /** The source or class file from which this class or
-     *  the class containing this symbol was generated, null if not applicable.
-     *  Overridden in ClassSymbol
-     */
-    def associatedFile(implicit ctx: Context): AbstractFile =
-      denot.topLevelClass.symbol.associatedFile
-
-    /** The class file from which this class was generated, null if not applicable. */
-    final def binaryFile(implicit ctx: Context): AbstractFile =
-      pickFile(associatedFile, classFile = true)
-
-    /** The source file from which this class was generated, null if not applicable. */
-    final def sourceFile(implicit ctx: Context): AbstractFile =
-      pickFile(associatedFile, classFile = false)
-
-   /** Desire to re-use the field in ClassSymbol which stores the source
-     *  file to also store the classfile, but without changing the behavior
-     *  of sourceFile (which is expected at least in the IDE only to
-     *  return actual source code.) So sourceFile has classfiles filtered out.
-     */
-    private def pickFile(file: AbstractFile, classFile: Boolean): AbstractFile =
-      if ((file eq null) || classFile != (file.path endsWith ".class")) null else file
-
-    /** The position of this symbol, or NoPosition is symbol was not loaded
-     *  from source.
-     */
-    def pos: Position = if (coord.isPosition) coord.toPosition else NoPosition
-
-// -------- GADT handling -----------------------------------------------
-
-    /** Perform given operation `op` where this symbol allows tightening of
-     *  its type bounds.
-     */
-    private[dotc] def withGADTFlexType[T](op: () => T)(implicit ctx: Context): () => T = { () =>
-      assert((denot is TypeParam) && denot.owner.isTerm)
-      val saved = denot
-      denot = denot.copySymDenotation(initFlags = denot.flags | GADTFlexType)
-      try op()
-      finally denot = saved
-    }
-
-    /** Disallow tightening of type bounds for this symbol from now on */
-    private[dotc] def resetGADTFlexType()(implicit ctx: Context): Unit = {
-      assert(denot is GADTFlexType)
-      denot = denot.copySymDenotation(initFlags = denot.flags &~ GADTFlexType)
-    }
-
-    /** Change info of this symbol to new, tightened type bounds */
-    private[core] def changeGADTInfo(bounds: TypeBounds)(implicit ctx: Context): Unit = {
-      assert(denot is GADTFlexType)
-      denot = denot.copySymDenotation(info = bounds)
-    }
-
-// -------- Printing --------------------------------------------------------
-
-    /** The prefix string to be used when displaying this symbol without denotation */
-    protected def prefixString = "Symbol"
-
-    override def toString: String =
-      if (lastDenot == null) s"Naked$prefixString#$id"
-      else lastDenot.toString// +"#"+id // !!! DEBUG
-
-    def toText(printer: Printer): Text = printer.toText(this)
-
-    def showLocated(implicit ctx: Context): String = ctx.locatedText(this).show
-    def showDcl(implicit ctx: Context): String = ctx.dclText(this).show
-    def showKind(implicit ctx: Context): String = ctx.kindString(this)
-    def showName(implicit ctx: Context): String = ctx.nameString(this)
-    def showFullName(implicit ctx: Context): String = ctx.fullNameString(this)
+  def calculateLineIndices(cs: Array[Char]) = {
+    val buf = new ArrayBuffer[Int]
+    buf += 0
+    for (i <- 0 until cs.length) if (isLineBreak(i)) buf += i + 1
+    buf += cs.length // sentinel, so that findLine below works smoother
+    buf.toArray
   }
+  private lazy val lineIndices: Array[Int] = calculateLineIndices(content)
 
-  type TermSymbol = Symbol { type ThisName = TermName }
-  type TypeSymbol = Symbol { type ThisName = TypeName }
+  /** Map line to offset of first character in line */
+  def lineToOffset(index : Int): Int = lineIndices(index)
 
-  class ClassSymbol private[Symbols] (coord: Coord, assocFile: AbstractFile)
-    extends Symbol(coord) {
+  /** A cache to speed up offsetToLine searches to similar lines */
+  private var lastLine = 0
 
-    type ThisName = TypeName
+  /** Convert offset to line in this source file
+   *  Lines are numbered from 0
+   */
+  def offsetToLine(offset: Int): Int = {
+    val lines = lineIndices
+    def findLine(lo: Int, hi: Int, mid: Int): Int =
+      if (offset < lines(mid)) findLine(lo, mid - 1, (lo + mid - 1) / 2)
+      else if (offset >= lines(mid + 1)) findLine(mid + 1, hi, (mid + 1 + hi) / 2)
+      else mid
+    lastLine = findLine(0, lines.length, lastLine)
+    lastLine
+  }
 
-    /** The source or class file from which this class was generated, null if not applicable. */
-    override def associatedFile(implicit ctx: Context): AbstractFile =
-      if (assocFile != null || (this.owner is PackageClass)) assocFile
-      else super.associatedFile
+  def startOfLine(offset: Int): Int = lineToOffset(offsetToLine(offset))
 
-    final def classDenot(implicit ctx: Context): ClassDenotation =
-      denot.asInstanceOf[ClassDenotation]
+  def nextLine(offset: Int): Int =
+    lineToOffset(offsetToLine(offset) + 1 min lineIndices.length - 1)
 
-    private var superIdHint: Int = -1
+  def lineContents(offset: Int): String =
+    content.slice(startOfLine(offset), nextLine(offset)).mkString
 
-    override def superId(implicit ctx: Context): Int = {
-      val hint = superIdHint
-      val key = this.typeRef
-      if (hint >= 0 && hint <= ctx.lastSuperId && (ctx.classOfId(hint) eq key))
-        hint
-      else {
-        val id = ctx.superIdOfClass get key match {
-          case Some(id) =>
-            id
-          case None =>
-            val id = ctx.nextSuperId
-            ctx.superIdOfClass(key) = id
-            ctx.classOfId(id) = key
-            id
-        }
-        superIdHint = id
-        id
-      }
+  def column(offset: Int): Int = {
+    var idx = startOfLine(offset)
+    var col = 0
+    while (idx != offset) {
+      col += (if (content(idx) == '\t') tabInc - col % tabInc else 1)
+      idx += 1
     }
-
-    /** Have we seen a subclass of this class? */
-    def hasChildren = superIdHint >= 0
-
-    override protected def prefixString = "ClassSymbol"
-  }
-
-  class ErrorSymbol(val underlying: Symbol, msg: => String)(implicit ctx: Context) extends Symbol(NoCoord) {
-    type ThisName = underlying.ThisName
-    denot = underlying.denot
-  }
-
-  object NoSymbol extends Symbol(NoCoord) {
-    denot = NoDenotation
+    col + 1
   }
 
-  implicit class Copier[N <: Name](sym: Symbol { type ThisName = N })(implicit ctx: Context) {
-    /** Copy a symbol, overriding selective fields */
-    def copy(
-        owner: Symbol = sym.owner,
-        name: N = sym.name,
-        flags: FlagSet = sym.flags,
-        info: Type = sym.info,
-        privateWithin: Symbol = sym.privateWithin,
-        coord: Coord = sym.coord,
-        associatedFile: AbstractFile = sym.associatedFile): Symbol =
-      if (sym.isClass)
-        ctx.newClassSymbol(owner, name.asTypeName, flags, _ => info, privateWithin, coord, associatedFile)
-      else
-        ctx.newSymbol(owner, name, flags, info, privateWithin, coord)
-  }
-
-  implicit def defn(implicit ctx: Context): Definitions = ctx.definitions
-
-  /** Makes all denotation operations available on symbols */
-  implicit def toDenot(sym: Symbol)(implicit ctx: Context): SymDenotation = sym.denot
-
-  /** Makes all class denotations available on class symbols */
-  implicit def toClassDenot(cls: ClassSymbol)(implicit ctx: Context): ClassDenotation = cls.classDenot
+  override def toString = file.toString
+}
 
-  var stubs: List[Symbol] = Nil // diagnostic
+object NoSource extends SourceFile("<no source>", Nil) {
+  override def exists = false
 }
+