diff options
Diffstat (limited to 'src/attic')
-rw-r--r-- | src/attic/scala/tools/nsc/models/Models.scala | 419 | ||||
-rw-r--r-- | src/attic/scala/tools/nsc/symtab/SymbolWalker.scala | 1 |
2 files changed, 0 insertions, 420 deletions
diff --git a/src/attic/scala/tools/nsc/models/Models.scala b/src/attic/scala/tools/nsc/models/Models.scala deleted file mode 100644 index a1344d8a05..0000000000 --- a/src/attic/scala/tools/nsc/models/Models.scala +++ /dev/null @@ -1,419 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Martin Odersky - */ - -package scala.tools.nsc -package models - -import scala.tools.nsc.Global - -/** This abstract class ... - * - * @author Sean McDirmid - * @version 1.0 - */ -abstract class Models { - val global: Global - import global._ - - def acceptPrivate = true - - object Kinds extends Enumeration { - type Kind = Value - val CONSTRUCTOR = Value("Constructor") - val OBJECT = Value("Object") - val CLASS = Value("Class") - val TRAIT = Value("Trait") - val DEF = Value("Def") - val VAL = Value("Val") - val VAR = Value("Var") - val ARG = Value("Arg") - val TPARAM = Value("Type") - } - import Kinds._ - - def KINDS = List(CLASS, TRAIT, OBJECT, CONSTRUCTOR, TPARAM, VAL, VAR, DEF) - - def labelFor(kind: Kind): String = kind.toString - - def stringsFor(mods: Modifiers) = { - var modString: List[String] = Nil - if (mods.isPrivate ) modString = "private" :: modString - if (mods.isProtected) modString = "protected" :: modString - if (mods.isOverride ) modString = "override" :: modString - if (mods.isAbstract ) modString = "abstract" :: modString - if (mods.isDeferred ) modString = "abstract" :: modString - if (mods.isCase ) modString = "case" :: modString - if (mods.isSealed ) modString = "sealed" :: modString - if (mods.isFinal ) modString = "final" :: modString - if (mods.isImplicit ) modString = "implicit" :: modString - modString - } - - def codeFor(kind: Kind): String = kind match { - case CONSTRUCTOR => codeFor(DEF) - case _ => labelFor(kind).toLowerCase() - } - - def pluralFor(kind: Kind): String = kind match { - case CLASS => "Classes" - case _ => labelFor(kind) + "s" - } - - def kindOf(tree: Tree) = { - val term0 = tree.symbol; - if (term0 != NoSymbol) { - if (term0.isVariable) VAR - else if (term0.isValueParameter) ARG - else if (term0.isMethod) { - if (term0.nameString.equals("this")) CONSTRUCTOR - else DEF - } - else if (term0.isClass) { - if (tree.asInstanceOf[MemberDef].mods.isTrait) TRAIT - else CLASS - } - else if (term0.isModule) OBJECT - else if (term0.isValue) VAL - else if (term0.isTypeParameter) TPARAM - else if (term0.isType) TPARAM - else { - // Console.err.println("UNRECOGNIZED SYMBOL: " + term0 + " " + name); - null - } - } else { - val ddef = tree.asInstanceOf[ValOrDefDef]; - if (ddef.mods.isMutable) VAR; - else VAL; - } - } - - abstract class Model - - // def textFor(tp : AbsTypeDef) : String = tp.toString() - - /** - * @param tree ... - * @return ... - */ - def textFor(tree: Tree): String = { - var ret = "" - if (tree.symbol != NoSymbol) tree.symbol.name.toString() - if (ret.equals("<init>")) ret = "this" - tree match { - case cdef: ClassDef => - ret = ret + "[" + - (for (tparam <- cdef.tparams) yield textFor(tparam)) + "]"; - cdef.mods - case vdef: ValOrDefDef => - vdef match { - case ddef: DefDef => - ret = ret + "[" + - (for (tparam <- ddef.tparams) yield textFor(tparam)) + "]"; - for (vparams <- ddef.vparamss) { - ret = ret + "(" + - (for (vparam <- vparams) yield textFor(vparam)) + ")"; - } - case _ => - } - ret = ret + " : " + textFor(vdef.tpt) -/* Martin to Sean: Please check whether this can be dropped or does it need to be adapted? - case atd: AbsTypeDef => - ret = ret + "[" + (for (tparam <- atd.tparams) yield textFor(tparam)) + "]" + - ((if(atd.hi ne null) " <: " + textFor(atd.hi) else "") + - (if(atd.lo ne null) " >: " + textFor(atd.lo) else "")); -*/ - case _ => - ret = ret + tree.toString() - } - ret - } - - def mods1(tree: Tree) = tree match { - case mdef: MemberDef => mdef.mods - case _ => NoMods - } - - abstract class HasTree(val parent: Composite) extends Model with Ordered[HasTree] { - var tree : Tree = _ - def update(tree0: Tree): Boolean = { - tree = tree0 - false - } - def replacedBy(tree0: Tree): Boolean = true - def text: String = textFor(tree) - var mods0 = NoMods - - def mods = if (mods0 != NoMods) mods0 else mods1(tree) - - override def toString(): String = tree.toString() - - def compare(that: HasTree): Int = { - val idx = KINDS.indexOf(kind) - val jdx = KINDS.indexOf(that.kind) - if (idx != jdx) return idx - jdx - val result = tree.symbol.nameString.compare(that.tree.symbol.nameString) - if (result != 0) result - else toString().compare(that.toString()) - } - def compare [b >: HasTree <% Ordered[b]](that: b): Int = { - if (that.isInstanceOf[HasTree]) - compare(that.asInstanceOf[HasTree]) - else -1 - } - - def kind = kindOf(tree) - - //override def add(from: Composite, model: HasTree): Unit = { parent.add(from, model) } - //override def remove(from: Composite, model: HasTree): Unit = { parent.remove(from, model) } - } - - class ImportMod(parent0: Composite) extends HasTree(parent0) { - def treex = tree.asInstanceOf[Import] - - override def replacedBy(tree0: Tree): Boolean = - if (super.replacedBy(tree0) && tree0.isInstanceOf[Import]) { - val tree1 = tree0.asInstanceOf[Import] - tree1.tpe == treex.tpe - } else - false - } - - class PackageMod(parent0: Composite) extends HasTree(parent0) { - def treex = tree.asInstanceOf[PackageDef] - } - - trait Composite extends Model { - import scala.collection.mutable._ - - class Members extends HashSet[HasTree] - // val members = new Members - object members extends Members - - def isMember(tree: Tree): Boolean = tree.isInstanceOf[Import] // imports welcome anywhere. - - def member(tree: Tree, members: List[Tree]): Tree = tree - - def update0(members1: List[Tree]): Boolean = { - // Console.err.println("update0 " + this + " " + members1) - // Martin: This is rather ugly code. We should use pattern matching here! - if (members1.length == 1 && members1.head.isInstanceOf[PackageDef]) - return update0(members1.head.asInstanceOf[PackageDef].stats) - val marked = new HashSet[HasTree] - var updated = false - for (mmbr1 <- members1) if (mmbr1.isInstanceOf[PackageDef]) { - Console.err.println("PACKAGE: " + mmbr1.symbol + " " + members1.length) - } else if (isMember(mmbr1)) { - val mmbr2 = member(mmbr1, members1) - if (mmbr2 ne null) { - var found = false - for (mmbr <- members) if (!found && mmbr.replacedBy(mmbr2)) { - //Console.err.println("REPLACE: " + mmbr + " with " + mmbr2) - mmbr.mods0 = mods1(mmbr1) - found = true - updated = mmbr.update(mmbr2) || updated - marked += mmbr - } - if (!found) { - updated = true - val add = modelFor(mmbr2, this) - add.update(mmbr2) - add.mods0 = mods1(mmbr1) & - ~symtab.Flags.ACCESSOR & ~symtab.Flags.SYNTHETIC - val sz = members.size - members += (add) - assert(members.size == sz + 1) - marked += add - } - } - // Console.err.println("update1 " + this + " " + members + " " + marked) - } - val sz = members.size - members.intersect(marked) - updated = updated || sz < members.size - // check if anything was removed! - updated - } - } - abstract class MemberMod(parent0: Composite) extends HasTree(parent0) { - def treex = tree.asInstanceOf[MemberDef] - - def name: Name = treex.name - - override def replacedBy(tree0: Tree): Boolean = - if (super.replacedBy(tree0) && tree0.isInstanceOf[MemberDef]) { - val tree1 = tree0.asInstanceOf[MemberDef] - treex.toString().equals(tree1.toString()) - } else false - - override def update(tree0: Tree): Boolean = { - val updated = (tree eq null) || (treex.mods != tree0.asInstanceOf[MemberDef].mods) - super.update(tree0) || updated; - } - } - - abstract class MemberComposite(parent0: Composite) extends MemberMod(parent0) with Composite - - trait HasClassObjects extends Composite { - override def isMember(tree: Tree): Boolean = - super.isMember(tree) || tree.isInstanceOf[ImplDef] - } - - abstract class ValOrDefMod(parent0: Composite) extends MemberComposite(parent0) with HasClassObjects { - override def replacedBy(tree0: Tree): Boolean = - super.replacedBy(tree0) && tree0.isInstanceOf[ValOrDefDef] - - override def update(tree0: Tree): Boolean = { - val tree1 = tree0.asInstanceOf[ValOrDefDef] - val updated = (tree eq null) || treex.tpe != tree1.tpe - update0(flatten(tree1.rhs, (tree2: Tree) => isMember(tree2))) - super.update(tree0) || updated - } - } - - class ValMod(parent0: Composite) extends ValOrDefMod(parent0) { - def treez = tree.asInstanceOf[ValDef] - override def replacedBy(tree0: Tree): Boolean = - super.replacedBy(tree0) && tree0.isInstanceOf[ValDef] - } - - class DefMod(parent0: Composite) extends ValOrDefMod(parent0) { - def treez = tree.asInstanceOf[DefDef] - - override def replacedBy(tree0: Tree) : Boolean = - if (super.replacedBy(tree0) && tree0.isInstanceOf[DefDef]) { - val tree1 = tree0.asInstanceOf[DefDef] - if (tree1.vparamss.length == treez.vparamss.length) { - val tpz = for (vd <- treez.vparamss) yield for (xd <- vd) yield xd.tpe; - val tp1 = for (vd <- tree1.vparamss) yield for (xd <- vd) yield xd.tpe; - tpz == tp1 - } else false - } else false - } - - abstract class ImplMod(parent0: Composite) - extends MemberComposite(parent0) with HasClassObjects { - override def replacedBy(tree0: Tree): Boolean = - super.replacedBy(tree0) && tree0.isInstanceOf[ImplDef] - override def isMember(tree: Tree): Boolean = (super.isMember(tree) || - (tree.isInstanceOf[ValOrDefDef] && - (acceptPrivate || !tree.asInstanceOf[ValOrDefDef].mods.isPrivate) - /* && !tree.asInstanceOf[ValOrDefDef].mods.isPrivate */ - /* && !tree.asInstanceOf[ValOrDefDef].mods.isAccessor */) || - treeInfo.isAliasTypeDef(tree)) - - override def member(tree: Tree, members: List[Tree]): Tree = { - val tree0 = if (tree.isInstanceOf[DefDef]) { - val ddef = tree.asInstanceOf[DefDef] - ddef.mods - if (ddef.mods.isAccessor && (ddef.symbol ne null)) { - val sym0 = ddef.symbol; - if (sym0.isSetter) return null; - assert(sym0.isGetter); - val sym = sym0.accessed - val ret = if (sym == NoSymbol) { - val sym = analyzer.underlying(sym0) - //val name = nme.getterToSetter(sym0.name) - //val setter = sym0.owner.info.decl(name); - val isVar = sym.isVariable; - val mods = (ddef.mods | - (if (isVar) symtab.Flags.MUTABLE else 0) | symtab.Flags.DEFERRED) & - ~symtab.Flags.ACCESSOR & ~symtab.Flags.SYNTHETIC - val tree = - ValDef(mods, ddef.name, ddef.tpt, ddef.rhs).setPos(ddef.pos).setSymbol(sym); - tree :: Nil; - } else for (member <- members if member.symbol == sym) yield member - if (ret.isEmpty) null - else ret.head - } else tree - } else super.member(tree, members) - - def sym = tree0.symbol - if ((tree0 eq null) || tree0.pos == NoPosition) null - else if (!acceptPrivate && - tree0.isInstanceOf[ValOrDefDef] && - tree.asInstanceOf[ValOrDefDef].mods.isPrivate) null - else tree0 - } - - def children(tree0: Tree): List[Tree] = - tree0.asInstanceOf[ImplDef].impl.body - - override def update(tree0: Tree): Boolean = { - var updated = update0(children(tree0)) - super.update(tree0) || updated - } - } - - class ClassMod(parent0: Composite) extends ImplMod(parent0) { - def treez = tree.asInstanceOf[ClassDef] - override def replacedBy(tree0: Tree): Boolean = - super.replacedBy(tree0) && tree0.isInstanceOf[ClassDef] - } - - class ObjectMod(parent0: Composite) extends ImplMod(parent0) { - def treez = tree.asInstanceOf[ModuleDef] - override def replacedBy(tree0: Tree): Boolean = - super.replacedBy(tree0) && tree0.isInstanceOf[ModuleDef] - } - class TypeMod(parent0: Composite) extends MemberMod(parent0) { - override def replacedBy(tree0 : Tree) : Boolean = (super.replacedBy(tree0) && tree0.isInstanceOf[TypeDef]); - } - def SourceMod(original: CompilationUnit) = new SourceMod(original) - - class SourceMod(val original: CompilationUnit) extends Composite with HasClassObjects { - update(original) - //var listener : Listener = null; - def update(unit: CompilationUnit) = unit.body match { - case pdef: PackageDef => try { - update0(pdef.stats) - } catch { - case e: Error => members.clear; update0(pdef.stats) - } - case _ => - } - - override def isMember(tree: Tree): Boolean = - super.isMember(tree) || tree.isInstanceOf[Import] - } - - def flatten0(exprs: List[Tree], filter: (Tree) => Boolean): List[Tree] = - for (expr <- exprs; t: Tree <- flatten(expr,filter)) yield t - - def flatten(expr: Tree, filter: (Tree) => Boolean): List[Tree] = - if (filter(expr)) expr :: Nil; else expr match { - case Block(stats, last) => - flatten0(stats, filter) ::: flatten(last, filter) - case If(cond, thenp, elsep) => - flatten(cond,filter) ::: flatten(thenp,filter) ::: flatten(elsep,filter); - case Assign(lhs, rhs) => - flatten(rhs, filter) - case CaseDef(pat, guard, body) => - flatten(body, filter) - case Return(expr0) => - flatten(expr0, filter) - case Throw(expr0) => - flatten(expr0,filter) - case Try(block, catches, finalizer) => - flatten(block, filter) ::: flatten(finalizer, filter) ::: flatten0(catches, filter) - case Match(selector, cases) => - flatten(selector, filter) ::: flatten0(cases, filter) - case Apply(fun, args) => - flatten(fun, filter) ::: flatten0(args, filter) - case TypeApply(fun, args) => - flatten(fun, filter) ::: flatten0(args, filter) - case _ => - Nil - } - - def modelFor(tree: Tree, parent: Composite): HasTree = tree match { - case _: ValDef => new ValMod(parent) - case _: DefDef => new DefMod(parent) - case _: ClassDef => new ClassMod(parent) - case _: ModuleDef => new ObjectMod(parent) - case _: TypeDef => new TypeMod(parent) - case _: Import => new ImportMod(parent) - } - -} diff --git a/src/attic/scala/tools/nsc/symtab/SymbolWalker.scala b/src/attic/scala/tools/nsc/symtab/SymbolWalker.scala index 8c111875dd..01b5c76cdc 100644 --- a/src/attic/scala/tools/nsc/symtab/SymbolWalker.scala +++ b/src/attic/scala/tools/nsc/symtab/SymbolWalker.scala @@ -11,7 +11,6 @@ trait SymbolWalker { def apply(pos : Position) : Symbol def putDef(sym : Symbol, pos : Position) : Unit = () } - import scala.collection.mutable.Map /* implicit def map2use(map : Map[Position,Symbol]) = new Visitor { def update(pos : Position, sym : Symbol) : Unit = map.update(pos, sym) |