From 3491b3d79dccf43cf1c25b7607d4df169fdbace5 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 21 Sep 2011 16:48:03 +0000 Subject: Removed duplicate class. --- src/compiler/scala/reflect/internal/Importer.scala | 300 --------------------- 1 file changed, 300 deletions(-) delete mode 100644 src/compiler/scala/reflect/internal/Importer.scala (limited to 'src') diff --git a/src/compiler/scala/reflect/internal/Importer.scala b/src/compiler/scala/reflect/internal/Importer.scala deleted file mode 100644 index 5e010bfb85..0000000000 --- a/src/compiler/scala/reflect/internal/Importer.scala +++ /dev/null @@ -1,300 +0,0 @@ -package scala.reflect -package internal -import com.sun.source.tree.ImportTree -import scala.collection.mutable.WeakHashMap - -trait Importers { self: SymbolTable => - - class Importer(val symMap: WeakHashMap[SymbolTable # Symbol, Symbol] = new WeakHashMap[SymbolTable # Symbol, Symbol]) { - - def importPosition(pos: SymbolTable # Position): Position = NoPosition - - def importSymbol(sym: SymbolTable#Symbol): Symbol = { - def importOrRelink: Symbol = - if (sym == null) - null - else if (sym.getClass == NoSymbol.getClass) - NoSymbol - else if (sym.isRoot) - definitions.RootClass - else { - val myowner = importSymbol(sym.owner) - val mypos = importPosition(sym.pos) - val myname = importName(sym.name) - - def doImport: Symbol = { - val mysym = sym match { - case x: SymbolTable # MethodSymbol => - val mysym = new MethodSymbol(myowner, mypos, myname) - mysym.referenced = importSymbol(x.referenced) - mysym - case x: SymbolTable # ModuleSymbol => - new ModuleSymbol(myowner, mypos, myname) - case x: SymbolTable # TermSymbol => - new TermSymbol(myowner, mypos, myname) - case x: SymbolTable # TypeSkolem => - new TypeSkolem(myowner, mypos, myname.toTypeName, x.unpackLocation match { - case null => null - case y: Tree => importTree(y) - case y: Symbol => importSymbol(y) - }) -/* - case x: SymbolTable#ModuleClassSymbol => - val mysym = new ModuleClassSymbol(myowner, mypos, myname.toTypeName) - mysym.sourceModule = importSymbol(x.sourceModule) - mysym -*/ - case x: SymbolTable # ClassSymbol => - val mysym = new ClassSymbol(myowner, mypos, myname.toTypeName) - if (sym.thisSym != sym) { - mysym.typeOfThis = importType(sym.typeOfThis) - mysym.thisSym.name = importName(sym.thisSym.name) - } - mysym - case x: SymbolTable # TypeSymbol => - new TypeSymbol(myowner, mypos, myname.toTypeName) - } - symMap(sym) = mysym - mysym setFlag sym.flags - mysym setInfo { - val mytypeParams = sym.typeParams map importSymbol - new LazyPolyType(mytypeParams) { - override def complete(s: Symbol) { - val result = sym.info match { - case PolyType(_, result) => result - case result => result - } - s setInfo polyType(mytypeParams, importType(result)) - s setAnnotations (sym.annotations map importAnnotationInfo) - } - } - } - } // end doImport - - if (myowner.isClass && !myowner.isRefinementClass && sym.owner.lookup(sym.name).exists) { - // symbol is in class scope, try to find equivalent one in local scope - if (sym.isOverloaded) - myowner.newOverloaded(myowner.thisType, sym.alternatives map importSymbol) - else { - var existing: Symbol = myowner.lookup(myname) - if (existing.isOverloaded) { - existing = - if (sym.isMethod) { - val localCopy = doImport - existing filter (_.tpe matchesType localCopy.tpe) - } else { - existing filter (!_.isMethod) - } - assert(!existing.isOverloaded) - } - if (existing.exists) existing - else { - val mysym = doImport - myowner.info.decls enter mysym - mysym - } - } - } else if (sym.isTypeParameter && sym.paramPos >= 0) - myowner.typeParams(sym.paramPos) - else - doImport - } - symMap getOrElseUpdate (sym, importOrRelink) - } - - def importType(tpe: SymbolTable#Type): Type = tpe match { - case x: SymbolTable#TypeRef => - TypeRef(importType(x.pre), importSymbol(x.sym), x.args map importType) - case x: SymbolTable#ThisType => - ThisType(importSymbol(x.typeSymbol)) - case x: SymbolTable#SingleType => - SingleType(importType(x.pre), importSymbol(x.sym)) - case x: SymbolTable#MethodType => - MethodType(x.params map importSymbol, importType(x.resultType)) - case x: SymbolTable#PolyType => - PolyType(x.typeParams map importSymbol, importType(x.resultType)) - case x: SymbolTable#NullaryMethodType => - NullaryMethodType(importType(x.resultType)) - case x: SymbolTable#ConstantType => - ConstantType(Constant(x.value.value)) - case x: SymbolTable#SuperType => - SuperType(importType(x.thistpe), importType(x.supertpe)) - case x: SymbolTable#TypeBounds => - TypeBounds(importType(x.lo), importType(x.hi)) - case x: SymbolTable#BoundedWildcardType => - BoundedWildcardType(importTypeBounds(x.bounds)) - case x: SymbolTable#ClassInfoType => - val myclazz = importSymbol(x.typeSymbol) - val myscope = if (myclazz.isPackageClass) newPackageScope(myclazz) else newScope - val myclazzTpe = ClassInfoType(x.parents map importType, myscope, myclazz) - myclazz setInfo polyType(myclazz.typeParams, myclazzTpe) // needed so that newly created symbols find their scope - for (sym <- x.decls) importSymbol(sym) // will enter itself into myclazz - myclazzTpe - case x: SymbolTable#RefinedType => - RefinedType(x.parents map importType, importScope(x.decls), importSymbol(x.typeSymbol)) - case x: SymbolTable#ExistentialType => - ExistentialType(x.typeParams map importSymbol, importType(x.resultType)) - case x: SymbolTable#OverloadedType => - OverloadedType(importType(x.pre), x.alternatives map importSymbol) - case x: SymbolTable#AntiPolyType => - AntiPolyType(importType(x.pre), x.targs map importType) - case x: SymbolTable#TypeVar => - new TypeVar(importType(x.origin), importTypeConstraint(x.constr0), x.typeArgs map importType, x.params map importSymbol) - case x: SymbolTable#NotNullType => - NotNullType(importType(x.underlying)) - case x: SymbolTable#AnnotatedType => - AnnotatedType(x.annotations map importAnnotationInfo, importType(x.underlying), importSymbol(x.selfsym)) - case x => - val xclazz = x.getClass - if (xclazz == ErrorType.getClass) ErrorType - else if (xclazz == WildcardType.getClass) WildcardType - else if (xclazz == NoType.getClass) NoType - else if (xclazz == NoPrefix.getClass) NoPrefix - else if (x == null) null - else throw new MatchError(x) - } - - def importTypeBounds(bounds: SymbolTable#TypeBounds) = importType(bounds).asInstanceOf[TypeBounds] - - def importAnnotationInfo(ann: SymbolTable#AnnotationInfo): AnnotationInfo = - AnnotationInfo(importType(ann.atp), ann.args map importTree, ann.assocs map { - case (name, arg) => (importName(name), importAnnotArg(arg)) - }) - - def importAnnotArg(arg: SymbolTable#ClassfileAnnotArg): ClassfileAnnotArg = arg match { - case x: SymbolTable#LiteralAnnotArg => - LiteralAnnotArg(Constant(x.const.value)) - case x: SymbolTable#ArrayAnnotArg => - ArrayAnnotArg(x.args map importAnnotArg) - case x: SymbolTable#ScalaSigBytes => - ScalaSigBytes(x.bytes) - case x: SymbolTable#NestedAnnotArg => - NestedAnnotArg(importAnnotationInfo(x.annInfo)) - } - - def importTypeConstraint(constr: SymbolTable#TypeConstraint): TypeConstraint = { - val result = new TypeConstraint(constr.loBounds map importType, constr.hiBounds map importType) - result.inst = importType(constr.inst) - result - } - - // !!! todo: override to vcater for PackageScopes - def importScope(decls: SymbolTable#Scope): Scope = - new Scope(decls.toList map importSymbol) - - def importName(name: SymbolTable#Name): Name = - if (name.isTypeName) newTypeName(name.toString) else newTermName(name.toString) - def importTypeName(name: SymbolTable#TypeName): TypeName = importName(name).toTypeName - def importTermName(name: SymbolTable#TermName): TermName = importName(name).toTermName - - def importModifiers(mods: SymbolTable#Modifiers): Modifiers = - new Modifiers(mods.flags, importName(mods.privateWithin), mods.annotations map importTree) - - def importImportSelector(sel: SymbolTable#ImportSelector): ImportSelector = - new ImportSelector(importName(sel.name), sel.namePos, importName(sel.rename), sel.renamePos) - - def importTree(tree: SymbolTable#Tree): Tree = { - tree match { - case x: SymbolTable#ClassDef => - new ClassDef(importModifiers(x.mods), importName(x.name).toTypeName, x.tparams map importTypeDef, importTemplate(x.impl)) - case x: SymbolTable#PackageDef => - new PackageDef(importRefTree(x.pid), x.stats map importTree) - case x: SymbolTable#ModuleDef => - new ModuleDef(importModifiers(x.mods), importName(x.name).toTermName, importTemplate(x.impl)) - case x: SymbolTable#ValDef => - new ValDef(importModifiers(x.mods), importName(x.name).toTermName, importTree(x.tpt), importTree(x.rhs)) - case x: SymbolTable#DefDef => - new DefDef(importModifiers(x.mods), importName(x.name).toTermName, x.tparams map importTypeDef, x.vparamss map (_ map importValDef), importTree(x.tpt), importTree(x.rhs)) - case x: SymbolTable#TypeDef => - new TypeDef(importModifiers(x.mods), importName(x.name).toTypeName, x.tparams map importTypeDef, importTree(x.rhs)) - case x: SymbolTable#LabelDef => - new LabelDef(importName(x.name).toTermName, x.params map importIdent, importTree(x.rhs)) - case x: SymbolTable#Import => - new Import(importTree(x.expr), x.selectors map importImportSelector) - case x: SymbolTable#Template => - new Template(x.parents map importTree, importValDef(x.self), x.body map importTree) - case x: SymbolTable#Block => - new Block(x.stats map importTree, importTree(x.expr)) - case x: SymbolTable#CaseDef => - new CaseDef(importTree(x.pat), importTree(x.guard), importTree(x.body)) - case x: SymbolTable#Alternative => - new Alternative(x.trees map importTree) - case x: SymbolTable#Star => - new Star(importTree(x.elem)) - case x: SymbolTable#Bind => - new Bind(importName(x.name), importTree(x.body)) - case x: SymbolTable#UnApply => - new UnApply(importTree(x.fun), x.args map importTree) - case x: SymbolTable#ArrayValue => - new ArrayValue(importTree(x.elemtpt), x.elems map importTree) - case x: SymbolTable#Function => - new Function(x.vparams map importValDef, importTree(x.body)) - case x: SymbolTable#Assign => - new Assign(importTree(x.lhs), importTree(x.rhs)) - case x: SymbolTable#If => - new If(importTree(x.cond), importTree(x.thenp), importTree(x.elsep)) - case x: SymbolTable#Match => - new Match(importTree(x.selector), x.cases map importCaseDef) - case x: SymbolTable#Return => - new Return(importTree(x.expr)) - case x: SymbolTable#Try => - new Try(importTree(x.block), x.catches map importCaseDef, importTree(x.finalizer)) - case x: SymbolTable#Throw => - new Throw(importTree(x.expr)) - case x: SymbolTable#New => - new New(importTree(x.tpt)) - case x: SymbolTable#Typed => - new Typed(importTree(x.expr), importTree(x.tpt)) - case x: SymbolTable#TypeApply => - new TypeApply(importTree(x.fun), x.args map importTree) - case x: SymbolTable#ApplyToImplicitArgs => - new ApplyToImplicitArgs(importTree(x.fun), x.args map importTree) - case x: SymbolTable#ApplyImplicitView => - new ApplyImplicitView(importTree(x.fun), x.args map importTree) - case x: SymbolTable#Apply => - new Apply(importTree(x.fun), x.args map importTree) - case x: SymbolTable#ApplyDynamic => - new ApplyDynamic(importTree(x.qual), x.args map importTree) - case x: SymbolTable#Super => - new Super(importTree(x.qual), importTypeName(x.mix)) - case x: SymbolTable#This => - new This(importName(x.qual).toTypeName) - case x: SymbolTable#Select => - new Select(importTree(x.qualifier), importName(x.name)) - case x: SymbolTable#BackQuotedIdent => - new BackQuotedIdent(importName(x.name)) - case x: SymbolTable#Ident => - new Ident(importName(x.name)) - case x: SymbolTable#Literal => - new Literal(Constant(x.value)) - case x: SymbolTable#TypeTree => - new TypeTree() - case x: SymbolTable#Annotated => - new Annotated(importTree(x.annot), importTree(x.arg)) - case x: SymbolTable#SingletonTypeTree => - new SingletonTypeTree(importTree(x.ref)) - case x: SymbolTable#SelectFromTypeTree => - new SelectFromTypeTree(importTree(x.qualifier), importName(x.name).toTypeName) - case x: SymbolTable#CompoundTypeTree => - new CompoundTypeTree(importTemplate(x.templ)) - case x: SymbolTable#AppliedTypeTree => - new AppliedTypeTree(importTree(x.tpt), x.args map importTree) - case x: SymbolTable#TypeBoundsTree => - new TypeBoundsTree(importTree(x.lo), importTree(x.hi)) - case x: SymbolTable#ExistentialTypeTree => - new ExistentialTypeTree(importTree(x.tpt), x.whereClauses map importTree) - case x => - if (x.getClass == EmptyTree.getClass) EmptyTree - else if (x == null) null - else throw new MatchError(x) - } - } // copyAttrs tree - - def importValDef(tree: SymbolTable#ValDef): ValDef = importTree(tree).asInstanceOf[ValDef] - def importTypeDef(tree: SymbolTable#TypeDef): TypeDef = importTree(tree).asInstanceOf[TypeDef] - def importTemplate(tree: SymbolTable#Template): Template = importTree(tree).asInstanceOf[Template] - def importRefTree(tree: SymbolTable#RefTree): RefTree = importTree(tree).asInstanceOf[RefTree] - def importIdent(tree: SymbolTable#Ident): Ident = importTree(tree).asInstanceOf[Ident] - def importCaseDef(tree: SymbolTable#CaseDef): CaseDef = importTree(tree).asInstanceOf[CaseDef] - } -} -- cgit v1.2.3