diff options
11 files changed, 173 insertions, 125 deletions
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index e8555633ce..72fa167f8e 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -14,10 +14,6 @@ import scala.tools.nsc.reporters._; import scala.collection.mutable.{HashSet,HashMap,ListBuffer} - - - - import symtab._; import symtab.classfile.{PickleBuffer, Pickler}; import util.Statistics; diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala index 78c1dd7365..df93143a1a 100644 --- a/src/compiler/scala/tools/nsc/ast/Trees.scala +++ b/src/compiler/scala/tools/nsc/ast/Trees.scala @@ -11,8 +11,8 @@ import java.io.PrintWriter; import scala.tools.nsc.util.{Position,SourceFile}; import symtab.Flags._; -mixin class Trees requires Global { +mixin class Trees requires Global { //statistics var nodeCount = 0; @@ -139,23 +139,29 @@ mixin class Trees requires Global { def keyword : String; final def hasFlag(mask: long): boolean = (mods.flags & mask) != 0; + + def verifyKeyword(keyword : String, source : SourceFile, pos : Int) : Boolean = { + assert(keyword != null); + source.beginsWith(pos, keyword + " "); + } + + def verifyKeyword(source : SourceFile, pos : Int) : Boolean = + verifyKeyword(keyword, source, pos); + + def namePos(source : SourceFile) : Int = if (pos == Position.NOPOS) Position.NOPOS else { assert(keyword != null); - if (!source.beginsWith(pos, keyword + " ")) { - val p = new Position(source, pos); - if (true) return Position.NOPOS; - else throw new Error(); - } - source.skipWhitespace(pos + keyword.length() + 1); + if (!verifyKeyword(source, pos)) Position.NOPOS; + else source.skipWhitespace(pos + keyword.length() + 1); } } /** Package clause */ case class PackageDef(name: Name, stats: List[Tree]) extends MemberDef { - def mods = NoMods; - def keyword = "package"; - } + def mods = NoMods; + def keyword = "package"; + } def PackageDef(sym: Symbol, stats: List[Tree]): PackageDef = PackageDef(sym.name, stats) setSymbol sym; @@ -168,8 +174,12 @@ mixin class Trees requires Global { /** Class definition */ case class ClassDef(mods: Modifiers, name: Name, tparams: List[AbsTypeDef], tpt: Tree, impl: Template) extends ImplDef { - def keyword = "class"; - } + def keyword = "class"; + + override def verifyKeyword(source : SourceFile, pos : Int) : Boolean = + super.verifyKeyword(source, pos) || verifyKeyword("trait", source, pos); + + } def ClassDef(sym: Symbol, impl: Template): ClassDef = posAssigner.atPos(sym.pos) { @@ -193,8 +203,8 @@ mixin class Trees requires Global { /** Singleton object definition */ case class ModuleDef(mods: Modifiers, name: Name, impl: Template) extends ImplDef { - def keyword = "object"; - } + def keyword = "object"; + } def ModuleDef(sym: Symbol, impl: Template): ModuleDef = posAssigner.atPos(sym.pos) { @@ -265,7 +275,7 @@ mixin class Trees requires Global { ret; } def namePos = pos - name.length; - } + } def AbsTypeDef(sym: Symbol): AbsTypeDef = posAssigner.atPos(sym.pos) { @@ -276,8 +286,8 @@ mixin class Trees requires Global { /** Type alias */ case class AliasTypeDef(mods: Modifiers, name: Name, tparams: List[AbsTypeDef], rhs: Tree) extends MemberDef { - def keyword = "type"; - } + def keyword = "type"; + } def AliasTypeDef(sym: Symbol, rhs: Tree): AliasTypeDef = posAssigner.atPos(sym.pos) { @@ -298,8 +308,8 @@ mixin class Trees requires Global { */ case class LabelDef(name: Name, params: List[Ident], rhs: Tree) extends DefTree with TermTree { - assert(rhs.isTerm); - } + assert(rhs.isTerm); + } def LabelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef = posAssigner.atPos(sym.pos) { @@ -526,10 +536,6 @@ mixin class Trees requires Global { } override def setPos(pos : Int) : this.type = { val ret = super.setPos(pos); - if (false && pos == 151 && original == null) { - System.err.println("TYPE: " + this + " POS=" + pos + " TPE=" + tpe); - Thread.dumpStack(); - } ret; } @@ -948,17 +954,17 @@ mixin class Trees requires Global { copy.ClassDef(tree, mods, name, transformAbsTypeDefs(tparams), transform(tpt), transformTemplate(impl)) } case ModuleDef(mods, name, impl) => - atOwner(tree.symbol.moduleClass) { - copy.ModuleDef(tree, mods, name, transformTemplate(impl)) + atOwner(tree.symbol.moduleClass) { + copy.ModuleDef(tree, mods, name, transformTemplate(impl)) } case ValDef(mods, name, tpt, rhs) => - atOwner(tree.symbol) { - copy.ValDef(tree, mods, name, transform(tpt), transform(rhs)) + atOwner(tree.symbol) { + copy.ValDef(tree, mods, name, transform(tpt), transform(rhs)) } case DefDef(mods, name, tparams, vparamss, tpt, rhs) => - atOwner(tree.symbol) { - copy.DefDef( - tree, mods, name, transformAbsTypeDefs(tparams), transformValDefss(vparamss), transform(tpt), transform(rhs)) + atOwner(tree.symbol) { + copy.DefDef( + tree, mods, name, transformAbsTypeDefs(tparams), transformValDefss(vparamss), transform(tpt), transform(rhs)) } case AbsTypeDef(mods, name, lo, hi) => atOwner(tree.symbol) { @@ -1187,13 +1193,13 @@ mixin class Trees requires Global { class TreeSubstituter(from: List[Symbol], to: List[Tree]) extends Transformer { override def transform(tree: Tree): Tree = tree match { case Ident(_) => - def subst(from: List[Symbol], to: List[Tree]): Tree = - if (from.isEmpty) tree - else if (tree.symbol == from.head) to.head - else subst(from.tail, to.tail); - subst(from, to) + def subst(from: List[Symbol], to: List[Tree]): Tree = + if (from.isEmpty) tree + else if (tree.symbol == from.head) to.head + else subst(from.tail, to.tail); + subst(from, to) case _ => - super.transform(tree) + super.transform(tree) } } @@ -1210,9 +1216,9 @@ mixin class Trees requires Global { val symSubst = new SubstSymMap(from, to); override def traverse(tree: Tree): unit = { def subst(from: List[Symbol], to: List[Symbol]): unit = { - if (!from.isEmpty) - if (tree.symbol == from.head) tree setSymbol to.head - else subst(from.tail, to.tail) + if (!from.isEmpty) + if (tree.symbol == from.head) tree setSymbol to.head + else subst(from.tail, to.tail) } if (tree.tpe != null) tree.tpe = symSubst(tree.tpe); if (tree.hasSymbol) subst(from, to); @@ -1224,7 +1230,7 @@ mixin class Trees requires Global { class ChangeOwnerTraverser(val oldowner: Symbol, val newowner: Symbol) extends Traverser { override def traverse(tree: Tree): unit = { if ((tree.isDef || tree.isInstanceOf[Function]) && tree.symbol != NoSymbol && tree.symbol.owner == oldowner) - tree.symbol.owner = newowner; + tree.symbol.owner = newowner; super.traverse(tree) } } @@ -1240,8 +1246,8 @@ mixin class Trees requires Global { private var pos: int = _; override def traverse(t: Tree): unit = if (t != EmptyTree && t.pos == Position.NOPOS) { - t.setPos(pos); - super.traverse(t); + t.setPos(pos); + super.traverse(t); } def atPos[T <: Tree](pos: int)(tree: T): T = { this.pos = pos; diff --git a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala index 0f0c5c1824..2247536e8e 100644 --- a/src/compiler/scala/tools/nsc/models/SemanticTokens.scala +++ b/src/compiler/scala/tools/nsc/models/SemanticTokens.scala @@ -13,6 +13,7 @@ class SemanticTokens(val compiler: Global) { abstract class Kind {} object OBJECT extends Kind; object CLASS extends Kind; + object TRAIT extends Kind; object DEF extends Kind; object VAL extends Kind; object VAR extends Kind; @@ -28,10 +29,12 @@ class SemanticTokens(val compiler: Global) { } + [_trait_] abstract class HasNext extends Token { var next0 : HasPrev = _; def next = next0; + } [_trait_] abstract class HasPrev extends Token { var prev0 : HasNext = _; @@ -41,6 +44,7 @@ class SemanticTokens(val compiler: Global) { def convertToGap : Pair[Int,Actual] = { val nextGap = next.isInstanceOf[Gap]; val prevGap = prev.isInstanceOf[Gap]; + if (prevGap) { val ret = prev.length; val gap = prev.asInstanceOf[Gap]; @@ -48,6 +52,7 @@ class SemanticTokens(val compiler: Global) { if (nextGap) { gap.setLength(gap.length + next.length); gap.next0 = next.next; + next.next.prev0 = gap; } else { gap.next0 = next; @@ -94,8 +99,6 @@ class SemanticTokens(val compiler: Global) { class Process(val unit : CompilationUnit) { def source = unit.source; - - def dbg(tree : Tree) = {( "TREE=" + tree + (if (tree != null) (" CLASS=" + tree.getClass()) else "") + @@ -133,6 +136,7 @@ class SemanticTokens(val compiler: Global) { else if (term0.isModule) OBJECT; else if (term0.isValue ) VAL; else if (term0.isTypeParameter) TPARAM; + else if (term0.isType ) TPARAM; else { // System.err.println("UNRECOGNIZED SYMBOL: " + term0 + " " + name); null; @@ -147,7 +151,7 @@ class SemanticTokens(val compiler: Global) { info.uses += this; override def tpe : Type = if (tpe0 != null) tpe0 else super.tpe; - override def toString() = "use-" + name; + override def toString() = "use-" + name + "-" + symbol.getClass(); } val list = new TokenList; @@ -243,7 +247,7 @@ class SemanticTokens(val compiler: Global) { throw e; } case tpt : TypeTree => - //System.err.println("UNKNOWN TPT0: " + tpe0 + " " + tpe0.args + " " + tpt); + //System.err.println("UNKNOWN TPT0: " + unit.source.dbg(tree.pos) + " " + tpt + " "+ tpe0 + " " + tpe0.args + " " + tpt); case sft : SelectFromTypeTree => build(sft.qualifier); // XXX: broken if (false) System.err.println("SFTT: " + sft + " sym=" + sft.symbol + " selector=" + sft.selector + " qual=" + sft.qualifier + " qual.sym=" + @@ -257,7 +261,7 @@ class SemanticTokens(val compiler: Global) { if (tpt.original != null) buildT(tpt.original, tpe); else { System.err.println("UNKNOWN TPT3: " + tree + " vs. " + tpe0 + " " + unit.source.content(tree.pos)); - } + } case ident : Ident => buildT(ident, tpe0.resultType); case select : Select => buildT(select, tpe0.resultType); case _ => System.err.println("UNKNOWN TPE: " + tree + " vs. " + tpe0 + " " + tree.getClass()); @@ -266,25 +270,25 @@ class SemanticTokens(val compiler: Global) { case cpt : CompoundTypeTree => buildTs(cpt.templ.parents, tpe0.parents); case _ : TypeTree => + System.err.println("UNKNOWN TPE13: " + dbg(tree) + " tpe0=" + tpe0 + " " + tpe0.parents); case _ => System.err.println("UNKNOWN TPE5: " + dbg(tree) + " tpe0=" + tpe0 + " " + tpe0.parents); - } case tpe0 : ThisType => tree match { case stt : SingletonTypeTree => stt.ref match { case ths : This => build(ths); case _ => System.err.println("UNKNOWN TPE11: " + tpe0 + " " + stt + " " + stt.ref + " " + stt.ref.getClass() + " " + unit.source.dbg(tree.pos)); } - case tt : TypeTree => /* ignore */ + case tt : TypeTree => + if (false) System.err.println("UNKNOWN TPE12: " + tpe0 + " " + tree + " " + tree.getClass() + " " + unit.source.dbg(tree.pos)); case _ => System.err.println("UNKNOWN TPE10: " + tpe0 + " " + tree + " " + tree.getClass() + " " + unit.source.dbg(tree.pos)); } case tpe0 : SingleType => { - // System.err.println("UNKNOWN TPE8: " + dbg(tree) + " TPE=" + tpe0 + " PRE=" + tpe0.pre + " SYM=" + tpe0.sym); + if (false) System.err.println("UNKNOWN TPE8: " + tree + " " + unit.source.dbg(tree.pos) + " TPE=" + tpe0 + " PRE=" + tpe0.pre + " SYM=" + tpe0.sym); } case ErrorType => - case _ => { System.err.println("UNKNOWN TPE4: " + dbg(tree) + " vs. " + tpe + " " + (if (tpe != null) "" + tpe.getClass() + " " + tpe.getClass().getSuperclass() else null)); } @@ -293,7 +297,10 @@ class SemanticTokens(val compiler: Global) { buildT (trees.head, types.head); buildTs(trees.tail, types.tail); }; - case tree : AbsTypeDef => buildDef(tree.symbol, tree.namePos); + case tree : AbsTypeDef => + //System.err.println("ABS: " + tree.symbol + " " + unit.source.dbg(tree.namePos) + " " + unit.source.dbg(tree.pos)); + buildDef(tree.symbol, tree.namePos); + buildDef(tree.symbol, tree.pos); case tree : Bind => buildDef(tree.symbol, tree.pos); build(tree.body); case tree : Ident => buildUse(tree.symbol, tree.pos, tree.tpe); @@ -304,9 +311,11 @@ class SemanticTokens(val compiler: Global) { case e : Error => System.err.println("SELECTQ: " + tree + " " + tree.qualifier + " " + unit.source.dbg(tree.qualifier.pos)); throw e; } try { - if (tree.pos >= unit.source.content.length) - System.err.println("BAD_SELECT_QUALIFIER " + tree + " @ " + unit.source.dbg(tree.pos)); - else { + if (tree.pos >= unit.source.content.length) { + if (false) System.err.println("BAD_SELECT_QUALIFIER " + tree + " @ " + unit.source.dbg(tree.pos)); + + } else { + //System.err.println("SELECT-0: " + tree.symbol + " " + unit.source.dbg(tree.pos) + " " + (tree.pos - selectPos(tree))); buildUse(tree.symbol, selectPos(tree), tree.tpe); } } catch { @@ -315,10 +324,8 @@ class SemanticTokens(val compiler: Global) { case tree : GenericApply => build(tree.fun0); build(tree.args0); - case tree : Typed => build(tree.expr); build(tree.tpt); - case tree : Import => build(tree.expr); - - case tree : Block => build(tree.stats); build(tree.expr); + case tree : Typed => build(tree.expr); build(tree.tpt); + case tree : Block => build(tree.stats); build(tree.expr); case tree : CaseDef => build(tree.pat); build(tree.guard); build(tree.body); case tree : Sequence => build(tree.trees); @@ -330,15 +337,21 @@ class SemanticTokens(val compiler: Global) { case tree : LabelDef => build(tree.rhs); case tree : Throw => build(tree.expr); case tree : Try => build(tree.block); build(tree.catches); build(tree.finalizer); - case tree : DocDef => build(tree.definition); case tree : Alternative => build(tree.trees); - case tree : Literal => ; - case tree : This => if (tree.symbol != null) buildUse(tree.symbol, tree.pos, tree.tpe); + case tree : This => + //System.err.println("THIS: " + tree.symbol + " " + tree.qual + " " + unit.source.dbg(tree.pos) + " " + tree.tpe); + if (tree.symbol != null) buildUse(tree.symbol, tree.pos, tree.tpe); + //Thread.dumpStack(); + case tree : AliasTypeDef => + System.err.println("ALIAS: " + tree); + build(tree.rhs); build(tree.tparams); buildDef(tree.symbol, tree.pos); case tree : Super => ; case tree : AppliedTypeTree => ; case tree : SingletonTypeTree => ; - case tree : Attributed => ; - case tree : AliasTypeDef => build(tree.rhs); build(tree.tparams); buildDef(tree.symbol, tree.pos); + case tree : Literal => ; + case tree : DocDef => build(tree.definition); + case tree : Attributed => build(tree.definition); + case tree : Import => build(tree.expr); case EmptyTree => ; case _ => ; System.err.println("BAIL: " + unit.source.dbg(tree0.pos) + " " + tree0 + " " + tree0.getClass()); @@ -352,8 +365,9 @@ class SemanticTokens(val compiler: Global) { def buildSym(term : Symbol, pos : Int, isDef : Boolean, tpe : Type) : Unit = if (term.hasFlag(Flags.ACCESSOR)) buildSym(term.accessed, pos, isDef, tpe); else if (pos == Position.NOPOS) { - System.err.println("NOPOS: " + term); - Thread.dumpStack(); + + System.err.println("NOPOS: " + term); + Thread.dumpStack(); } else if (term != NoSymbol) { val name = NameTransformer.decode(term.name.toString()).toString().trim(); val buf = unit.source.content; @@ -361,11 +375,18 @@ class SemanticTokens(val compiler: Global) { var idx = 0; if (cs.length + pos > buf.length) return; else while (idx < cs.length) { - if (buf(pos + idx) != cs(idx)) return; + if (buf(pos + idx) != cs(idx)) { + //System.err.println("MISMATCH: " + name + "[" + idx + "] " + unit.source.dbg(pos)); + //Thread.dumpStack(); + return; + } else idx = idx + 1; } if (cs.length + pos + 1 < buf.length) { - if (Character.isJavaIdentifierPart(buf(pos + cs.length))) return; + if (Character.isJavaIdentifierPart(buf(pos + cs.length))) { + //System.err.println("MISMATCH: " + name + "[last] " + unit.source.dbg(pos)); + return; + } } try { list.put(pos, (if (isDef) new Def(term) else new Use(term, tpe))); diff --git a/src/compiler/scala/tools/nsc/symtab/Scopes.scala b/src/compiler/scala/tools/nsc/symtab/Scopes.scala index 81c12dc177..921d9f9cc0 100644 --- a/src/compiler/scala/tools/nsc/symtab/Scopes.scala +++ b/src/compiler/scala/tools/nsc/symtab/Scopes.scala @@ -102,11 +102,11 @@ mixin class Scopes requires SymbolTable { def enter(e: ScopeEntry): unit = { elemsCache = null; if (hashtable != null) { - val i = e.sym.name.start & HASHMASK; - elems.tail = hashtable(i); - hashtable(i) = elems; + val i = e.sym.name.start & HASHMASK; + elems.tail = hashtable(i); + hashtable(i) = elems; } else if (size >= MIN_HASH) { - createHash; + createHash; } } @@ -128,10 +128,10 @@ mixin class Scopes requires SymbolTable { private def enterInHash(e: ScopeEntry): unit = { if (e != null) { - enterInHash(e.next); - val i = e.sym.name.start & HASHMASK; - e.tail = hashtable(i); - hashtable(i) = e; + enterInHash(e.next); + val i = e.sym.name.start & HASHMASK; + e.tail = hashtable(i); + hashtable(i) = e; } } @@ -139,20 +139,20 @@ mixin class Scopes requires SymbolTable { */ def unlink(e: ScopeEntry): unit = { if (elems == e) { - elems = e.next; + elems = e.next; } else { - var e1 = elems; - while (e1.next != e) e1 = e1.next; - e1.next = e.next; + var e1 = elems; + while (e1.next != e) e1 = e1.next; + e1.next = e.next; } if (hashtable != null) { - var e1 = hashtable(e.sym.name.start & HASHMASK); - if (e1 == e) { - hashtable(e.sym.name.start & HASHMASK) = e.tail; - } else { - while (e1.tail != e) e1 = e1.tail; - e1.tail = e.tail; - } + var e1 = hashtable(e.sym.name.start & HASHMASK); + if (e1 == e) { + hashtable(e.sym.name.start & HASHMASK) = e.tail; + } else { + while (e1.tail != e) e1 = e1.tail; + e1.tail = e.tail; + } } elemsCache = null } @@ -162,7 +162,7 @@ mixin class Scopes requires SymbolTable { var e = lookupEntry(sym.name); while (e != null) { if (e.sym == sym) unlink(e); - e = lookupNextEntry(e) + e = lookupNextEntry(e) } } @@ -178,11 +178,11 @@ mixin class Scopes requires SymbolTable { def lookupEntry(name: Name): ScopeEntry = { var e: ScopeEntry = null; if (false & hashtable != null) { - e = hashtable(name.start & HASHMASK); - while (e != null && e.sym.name != name) e = e.tail; + e = hashtable(name.start & HASHMASK); + while (e != null && e.sym.name != name) e = e.tail; } else { - e = elems; - while (e != null && e.sym.name != name) e = e.next; + e = elems; + while (e != null && e.sym.name != name) e = e.next; } e } @@ -191,9 +191,9 @@ mixin class Scopes requires SymbolTable { def lookupNextEntry(entry: ScopeEntry): ScopeEntry = { var e = entry; if (hashtable != null) //debug - do { e = e.tail } while (e != null && e.sym.name != entry.sym.name) + do { e = e.tail } while (e != null && e.sym.name != entry.sym.name) else - do { e = e.next } while (e != null && e.sym.name != entry.sym.name); + do { e = e.next } while (e != null && e.sym.name != entry.sym.name); e } diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 256ac25105..b0f0b251e0 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -111,19 +111,19 @@ abstract class SymbolLoaders { val name = newTermName(str); val clazz = owner.newClass(Position.NOPOS, name.toTypeName); val module = owner.newModule(Position.NOPOS, name); - clazz.setInfo(completer); - module.setInfo(completer); - module.moduleClass.setInfo(moduleClassLoader); - owner.info.decls.enter(clazz); - owner.info.decls.enter(module); + clazz.setInfo(completer); + module.setInfo(completer); + module.moduleClass.setInfo(moduleClassLoader); + owner.info.decls.enter(clazz); + owner.info.decls.enter(module); /* if (completer.sourceFile != null) { clazz.sourceFile = completer.sourceFile; module.moduleClass.sourceFile = completer.sourceFile } */ - assert(clazz.linkedModule == module, module); - assert(module.linkedClass == clazz, clazz); + assert(clazz.linkedModule == module, module); + assert(module.linkedClass == clazz, clazz); } val classes = new HashMap[String, ClassPath.Context]; @@ -190,7 +190,13 @@ abstract class SymbolLoaders { val global: SymbolLoaders.this.global.type = SymbolLoaders.this.global; override def sourcePath = sourcePath0; /* could be null */ } - protected def doComplete(root: Symbol): unit = classfileParser.parse(classFile, root); + protected def doComplete(root: Symbol): unit = { + classfileParser.parse(classFile, root); + if (sourceFile != null) root match { + case clazz : ClassSymbol => clazz.sourceFile = sourceFile; + case _ => + } + } protected def kindString: String = "class file"; protected def sourceString = classFile.toString(); } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index f33b08fba4..eb06ce0332 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -335,27 +335,28 @@ abstract class ClassfileParser { in.skip(attrLen) case nme.ConstantValueATTR => val c = pool.getConstant(in.nextChar()); - val c1 = convertTo(c, symtype); + val c1 = convertTo(c, symtype); if (c1 != null) sym.setInfo(ConstantType(c1)); else System.out.println("failure to convert "+c+" to "+symtype);//debug case nme.InnerClassesATTR => parseInnerClasses() case nme.ScalaSignatureATTR => unpickler.unpickle(in.buf, in.bp, clazz, staticModule); - this.isScala = true; + this.isScala = true; case nme.JacoMetaATTR => val meta = pool.getName(in.nextChar()).toString().trim(); metaParser.parse(meta, sym, symtype); - this.hasMeta = true; - case nme.SourceFileATTR => - assert(attrLen == 2); - val source = pool.getName(in.nextChar()); - //System.out.println("SOURCE: " + source);//debug - if (sourcePath != null) { - val sourceFile = sourcePath.lookupPath(source.toString(), false); - clazz.sourceFile = sourceFile; - staticModule.moduleClass.sourceFile = sourceFile - } + this.hasMeta = true; + case nme.SourceFileATTR => + assert(attrLen == 2); + val source = pool.getName(in.nextChar()); + if (sourcePath != null) { + val sourceFile0 = sourcePath.lookupPath(source.toString(), false); + if (sourceFile0 != null && clazz.sourceFile == null) { + clazz.sourceFile = sourceFile0; + } + staticModule.moduleClass.sourceFile = clazz.sourceFile + } case _ => in.skip(attrLen) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 0390d8b6ea..b91c0c17b7 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -16,12 +16,15 @@ mixin class Typers requires Analyzer { import definitions._ import posAssigner.atPos + var appcnt = 0 var idcnt = 0 var selcnt = 0 var implcnt = 0 var impltime = 0l + + private val transformed = new HashMap[Tree, Tree] private val superDefs = new HashMap[Symbol, ListBuffer[Tree]] @@ -29,7 +32,7 @@ mixin class Typers requires Analyzer { def resetTyper: unit = { resetContexts transformed.clear - superDefs.clear + superDefs .clear } def newTyper(context: Context): Typer = new Typer(context) diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala index d24c4b1348..af7287bdb5 100644 --- a/src/compiler/scala/tools/nsc/util/ClassPath.scala +++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala @@ -67,7 +67,6 @@ object ClassPath { if (source0 == null) null; else new Source(source0, head.source.compile); }; - new Context(entry :: ret.entries); } } diff --git a/src/compiler/scala/tools/nsc/util/Position.scala b/src/compiler/scala/tools/nsc/util/Position.scala index 29f4d74cf7..290eb7e248 100644 --- a/src/compiler/scala/tools/nsc/util/Position.scala +++ b/src/compiler/scala/tools/nsc/util/Position.scala @@ -19,6 +19,15 @@ object Position { val FIRSTLINE = 1; def line(source : SourceFile, offset : Int) = (new Position(source, offset)).line; + + def lineToOffset(line : Int) = { + assert(line >= 1); + NOPOS - line; + } + def offsetToLine(pos : Int) = { + assert(pos < NOPOS); + NOPOS - pos; + } } @@ -30,9 +39,14 @@ class Position( val source : SourceFile, val offset: Int) { def this(sourceName : String) = this(new SourceFile(sourceName, new Array[Char](0)), Position.NOPOS); def this(sourceName : String, _offset : Int) = this(new SourceFile(sourceName, new Array[Char](0)), _offset); - def hasOffset = offset != NOPOS; + private def hasOffset = offset > NOPOS; + private def isLine = offset < NOPOS; + + + def line: Int = + if (hasOffset) source.offsetToLine(offset) + FIRSTLINE + else if (isLine) Position.offsetToLine(offset) else NOLINE; - def line: Int = if (hasOffset) source.offsetToLine(offset) + FIRSTLINE else NOLINE; // for display purposes only. def column: Int = if (hasOffset) { var column = 1; @@ -52,8 +66,9 @@ class Position( val source : SourceFile, val offset: Int) { def dbgString = - if (!hasOffset) "NOP" - else if (offset >= source.content.length) "OB-" + offset else { + if (isLine) "line-" + line; + else if (!hasOffset) "NOP"; + else if (offset >= source.content.length) "out-of-bounds-" + offset else { val ret = "offset=" + offset + " line=" + line; var add = ""; while (offset + add.length() < source.content.length && diff --git a/src/compiler/scala/tools/nsc/util/SourceFile.scala b/src/compiler/scala/tools/nsc/util/SourceFile.scala index 0d4354d325..9a315bc23b 100644 --- a/src/compiler/scala/tools/nsc/util/SourceFile.scala +++ b/src/compiler/scala/tools/nsc/util/SourceFile.scala @@ -7,6 +7,7 @@ ** $Id$ \* */ + package scala.tools.nsc.util; import scala.tools.util.AbstractFile; import scala.tools.util.CharArrayFile; diff --git a/src/compiler/scala/tools/util/PlainFile.java b/src/compiler/scala/tools/util/PlainFile.java index 13b1bf2e4c..56feb847fb 100644 --- a/src/compiler/scala/tools/util/PlainFile.java +++ b/src/compiler/scala/tools/util/PlainFile.java @@ -46,7 +46,7 @@ public class PlainFile extends AbstractFile { protected PlainFile(File file) { this.file = file; assert file != null; - if (!file.exists()) throw new Error("non-existent file: " + file); + if (!file.exists()) throw new Error("non-existent file: " + file); } //######################################################################## |