diff options
29 files changed, 82 insertions, 101 deletions
diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala index 1ab46b1a25..9571df6fe0 100644 --- a/src/compiler/scala/tools/nsc/Interpreter.scala +++ b/src/compiler/scala/tools/nsc/Interpreter.scala @@ -13,12 +13,11 @@ import java.net.{ MalformedURLException, URL } import java.lang.reflect import reflect.InvocationTargetException +import scala.collection.{ mutable, immutable } import scala.PartialFunction.{ cond, condOpt } import scala.tools.util.PathResolver import scala.reflect.Manifest -import scala.collection.mutable import scala.collection.mutable.{ ListBuffer, HashSet, HashMap, ArrayBuffer } -import scala.collection.immutable.Set import scala.tools.nsc.util.ScalaClassLoader import ScalaClassLoader.URLClassLoader import scala.util.control.Exception.{ Catcher, catching, ultimately, unwrapping } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 392afcc14e..6f41b3ac47 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -1467,7 +1467,7 @@ self => * | val Pattern1 `=' Expr */ def enumerators(): List[Enumerator] = { - val newStyle = in.token != VAL // todo: deprecate old style + val newStyle = in.token != VAL if (!newStyle) deprecationWarning(in.offset, "for (val x <- ... ) has been deprecated; use for (x <- ... ) instead") val enums = new ListBuffer[Enumerator] @@ -2598,7 +2598,6 @@ self => in.token == TRAIT || in.token == OBJECT || in.token == CASEOBJECT || - in.token == LBRACKET || //todo: remove in.token == AT || isModifier) { stats ++= joinComment(List(topLevelTmplDef)) @@ -2649,7 +2648,7 @@ self => } else if (isExprIntro) { in.flushDoc stats += statement(InTemplate) - } else if (isDefIntro || isModifier || in.token == LBRACKET /*todo: remove */ || in.token == AT) { + } else if (isDefIntro || isModifier || in.token == AT) { stats ++= joinComment(nonLocalDefOrDcl) } else if (!isStatSep) { syntaxErrorOrIncomplete("illegal start of definition", true) diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala index 654acc7fe9..0e76044977 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala @@ -8,8 +8,8 @@ package scala.tools.nsc package backend.icode package analysis -import scala.collection.mutable.{HashMap, Map} -import scala.collection.immutable.{Set, ListSet} +import scala.collection.{ mutable, immutable } +import scala.collection.immutable.{ Set, ListSet } /** * Compute liveness information for local variables. @@ -37,8 +37,8 @@ abstract class Liveness { var method: IMethod = _ - val gen: Map[BasicBlock, Set[Local]] = new HashMap() - val kill:Map[BasicBlock, Set[Local]] = new HashMap() + val gen: mutable.Map[BasicBlock, Set[Local]] = new mutable.HashMap() + val kill: mutable.Map[BasicBlock, Set[Local]] = new mutable.HashMap() def init(m: IMethod) { this.method = m diff --git a/src/compiler/scala/tools/nsc/symtab/Positions.scala b/src/compiler/scala/tools/nsc/symtab/Positions.scala index 58b9164988..2290705bbf 100644 --- a/src/compiler/scala/tools/nsc/symtab/Positions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Positions.scala @@ -1,9 +1,7 @@ package scala.tools.nsc package symtab -import ast.Trees -import scala.tools.nsc.util.{SourceFile, Position, RangePosition, OffsetPosition, NoPosition, WorkScheduler} -import scala.collection.mutable.ListBuffer +import scala.tools.nsc.util.{ SourceFile, Position, OffsetPosition, NoPosition } trait Positions { self: scala.tools.nsc.symtab.SymbolTable => diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 1f9f1c9701..2452081c05 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -6,17 +6,14 @@ package scala.tools.nsc package symtab -import java.io.{File, IOException} +import java.io.IOException +import ch.epfl.lamp.compiler.msil.{ Type => MSILType, Attribute => MSILAttribute } -import ch.epfl.lamp.compiler.msil.{Type => MSILType, Attribute => MSILAttribute} - -import scala.collection.mutable.{HashMap, HashSet, ListBuffer} import scala.compat.Platform.currentTime import scala.tools.nsc.io.AbstractFile -import scala.tools.nsc.util.{ ClassPath, JavaClassPath } +import scala.tools.nsc.util.{ ClassPath } import classfile.ClassfileParser import Flags._ - import util.Statistics._ /** This class ... diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index fb86f75a2e..4c17ea8f50 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -7,10 +7,10 @@ package scala.tools.nsc package symtab +import scala.collection.{ mutable, immutable } import scala.collection.mutable.ListBuffer -import scala.collection.immutable.Map import io.AbstractFile -import util.{Position, NoPosition, BatchSourceFile} +import util.{ Position, NoPosition, BatchSourceFile } import util.Statistics._ import Flags._ @@ -31,7 +31,7 @@ trait Symbols extends reflect.generic.Symbols { self: SymbolTable => protected var lockedSyms = collection.immutable.Set[Symbol]() /** Used to keep track of the recursion depth on locked symbols */ - private var recursionTable = Map.empty[Symbol, Int] + private var recursionTable = immutable.Map.empty[Symbol, Int] private var nextexid = 0 private def freshExistentialName() = { diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index e68fb73596..d4f322ed9f 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -2,15 +2,14 @@ * Copyright 2005-2010 LAMP/EPFL * @author Martin Odersky */ -// package scala.tools.nsc package symtab -import scala.collection.immutable -import scala.collection.mutable.{ListBuffer, HashMap, WeakHashMap} +import scala.collection.{ mutable, immutable } +import scala.collection.mutable.ListBuffer import ast.TreeGen -import util.{HashSet, Position, NoPosition} +import util.{ Position, NoPosition } import util.Statistics._ import Flags._ import scala.util.control.ControlThrowable @@ -146,7 +145,7 @@ trait Types extends reflect.generic.Types { self: SymbolTable => * It makes use of the fact that these two operations depend only on the parents, * not on the refinement. */ - val intersectionWitness = new WeakHashMap[List[Type], Type] + val intersectionWitness = new mutable.WeakHashMap[List[Type], Type] private object gen extends { val global : Types.this.type = Types.this @@ -1478,7 +1477,7 @@ trait Types extends reflect.generic.Types { self: SymbolTable => private final val Initializing = 1 private final val Initialized = 2 - private type RefMap = Map[Symbol, collection.immutable.Set[Symbol]] + private type RefMap = Map[Symbol, immutable.Set[Symbol]] /** All type parameters reachable from given type parameter * by a path which contains at least one expansive reference. @@ -1636,7 +1635,7 @@ trait Types extends reflect.generic.Types { self: SymbolTable => } private var volatileRecursions: Int = 0 - private val pendingVolatiles = new collection.mutable.HashSet[Symbol] + private val pendingVolatiles = new mutable.HashSet[Symbol] /** A class for named types of the form * `<prefix>.<sym.name>[args]' @@ -2254,7 +2253,7 @@ A type's typeSymbol should never be inspected directly. // encapsulate suspension so we can automatically link the suspension of cloned typevars to their original if this turns out to be necessary def Suspension = new Suspension class Suspension { - private val suspended = collection.mutable.HashSet[TypeVar]() + private val suspended = mutable.HashSet[TypeVar]() def suspend(tv: TypeVar): Unit = { tv.suspended = true suspended += tv @@ -2862,13 +2861,13 @@ A type's typeSymbol should never be inspected directly. // Hash consing -------------------------------------------------------------- private val initialUniquesCapacity = 4096 - private var uniques: HashSet[AnyRef] = _ + private var uniques: util.HashSet[AnyRef] = _ private var uniqueRunId = NoRunId private def unique[T <: AnyRef](tp: T): T = { incCounter(rawTypeCount) if (uniqueRunId != currentRunId) { - uniques = new HashSet("uniques", initialUniquesCapacity) + uniques = new util.HashSet("uniques", initialUniquesCapacity) uniqueRunId = currentRunId } (uniques findEntryOrUpdate tp).asInstanceOf[T] @@ -3201,8 +3200,8 @@ A type's typeSymbol should never be inspected directly. } } - private val emptySymMap = scala.collection.immutable.Map[Symbol, Symbol]() - private val emptySymCount = scala.collection.immutable.Map[Symbol, Int]() + private val emptySymMap = immutable.Map[Symbol, Symbol]() + private val emptySymCount = immutable.Map[Symbol, Int]() def typeParamsToExistentials(clazz: Symbol, tparams: List[Symbol]): List[Symbol] = { val eparams = for ((tparam, i) <- tparams.zipWithIndex) yield { @@ -4336,9 +4335,9 @@ A type's typeSymbol should never be inspected directly. */ def isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean = (tps1 corresponds tps2)(_ =:= _) - private val pendingSubTypes = new collection.mutable.HashSet[SubTypePair] + private val pendingSubTypes = new mutable.HashSet[SubTypePair] private var basetypeRecursions: Int = 0 - private val pendingBaseTypes = new collection.mutable.HashSet[Type] + private val pendingBaseTypes = new mutable.HashSet[Type] def isSubType(tp1: Type, tp2: Type): Boolean = isSubType(tp1, tp2, AnyDepth) @@ -5052,8 +5051,8 @@ A type's typeSymbol should never be inspected directly. isNumericValueType(tp1) && isNumericValueType(tp2) && isNumericSubClass(tp1.typeSymbol, tp2.typeSymbol) - private val lubResults = new HashMap[(Int, List[Type]), Type] - private val glbResults = new HashMap[(Int, List[Type]), Type] + private val lubResults = new mutable.HashMap[(Int, List[Type]), Type] + private val glbResults = new mutable.HashMap[(Int, List[Type]), Type] def lub(ts: List[Type]): Type = try { lub(ts, lubDepth(ts)) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala index 602b3a8637..cbc79b215d 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala @@ -10,8 +10,8 @@ package classfile import java.io.{ File, IOException } import java.lang.Integer.toHexString -import scala.collection.immutable.{Map, ListMap} -import scala.collection.mutable.{ListBuffer, ArrayBuffer} +import scala.collection.{ mutable, immutable } +import scala.collection.mutable.{ ListBuffer, ArrayBuffer } import scala.tools.nsc.io.AbstractFile import scala.annotation.switch import reflect.generic.PickleBuffer @@ -690,7 +690,7 @@ abstract class ClassfileParser { } def existentialType(tparams: List[Symbol], tp: Type): Type = if (tparams.isEmpty) tp else ExistentialType(tparams, tp) - def sig2type(tparams: Map[Name,Symbol], skiptvs: Boolean): Type = { + def sig2type(tparams: immutable.Map[Name,Symbol], skiptvs: Boolean): Type = { val tag = sig(index); index += 1 tag match { case BYTE_TAG => definitions.ByteClass.tpe @@ -797,7 +797,7 @@ abstract class ClassfileParser { } } // sig2type(tparams, skiptvs) - def sig2typeBounds(tparams: Map[Name, Symbol], skiptvs: Boolean): Type = { + def sig2typeBounds(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean): Type = { val ts = new ListBuffer[Type] while (sig(index) == ':') { index += 1 diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index e3bd67ec81..3b63ce2862 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -7,9 +7,9 @@ package scala.tools.nsc package symtab package classfile -import java.lang.{Float, Double} -import util.{ Position, NoPosition, ShowPickled } -import collection.mutable.Set +import java.lang.Float.floatToIntBits +import java.lang.Double.doubleToLongBits +import util.{ ShowPickled } import reflect.generic.{ PickleBuffer, PickleFormat } import PickleFormat._ import Flags._ @@ -597,8 +597,8 @@ abstract class Pickler extends SubComponent { case c @ Constant(_) => if (c.tag == BooleanTag) writeLong(if (c.booleanValue) 1 else 0) else if (ByteTag <= c.tag && c.tag <= LongTag) writeLong(c.longValue) - else if (c.tag == FloatTag) writeLong(Float.floatToIntBits(c.floatValue)) - else if (c.tag == DoubleTag) writeLong(Double.doubleToLongBits(c.doubleValue)) + else if (c.tag == FloatTag) writeLong(floatToIntBits(c.floatValue)) + else if (c.tag == DoubleTag) writeLong(doubleToLongBits(c.doubleValue)) else if (c.tag == StringTag) writeRef(newTermName(c.stringValue)) else if (c.tag == ClassTag) writeRef(c.typeValue) else if (c.tag == EnumTag) writeRef(c.symbolValue) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala index 05ffc6c7b7..a2e7f425b6 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/UnPickler.scala @@ -7,13 +7,8 @@ package scala.tools.nsc package symtab package classfile -import java.io.IOException -import java.lang.{Float, Double} - import Flags._ import scala.reflect.generic.PickleFormat._ -import collection.mutable.{HashMap, ListBuffer} -import annotation.switch /** @author Martin Odersky * @version 1.0 diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala index f1ed9f43a0..252055a63f 100644 --- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala +++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala @@ -8,7 +8,8 @@ package transform import symtab._ import Flags._ -import collection.mutable.{HashMap, ListBuffer} +import scala.collection.{ mutable, immutable } +import collection.mutable.ListBuffer abstract class AddInterfaces extends InfoTransform { import global._ // the global environment @@ -38,13 +39,13 @@ abstract class AddInterfaces extends InfoTransform { /** A lazily constructed map that associates every non-interface trait with * its implementation class. */ - private val implClassMap = new HashMap[Symbol, Symbol] + private val implClassMap = new mutable.HashMap[Symbol, Symbol] /** A lazily constructed map that associates every concrete method in a non-interface * trait that's currently compiled with its corresponding method in the trait's * implementation class. */ - private val implMethodMap = new HashMap[Symbol, Symbol] + private val implMethodMap = new mutable.HashMap[Symbol, Symbol] override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = { implClassMap.clear diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 4c20a901ef..5b30bf59ec 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -6,6 +6,7 @@ package scala.tools.nsc package transform +import scala.collection.{ mutable, immutable } import scala.collection.mutable.ListBuffer import symtab.Flags._ import util.TreeSet @@ -16,7 +17,6 @@ import util.TreeSet abstract class Constructors extends Transform with ast.TreeDSL { import global._ import definitions._ - import collection.mutable /** the following two members override abstract members in Transform */ val phaseName: String = "constructors" diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index 635a1983e2..80f32ec66f 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -7,9 +7,7 @@ package scala.tools.nsc package transform import scala.tools.nsc.symtab.classfile.ClassfileConstants._ -import scala.collection.mutable.{HashMap,ListBuffer} -import scala.collection.immutable.Set -import scala.util.control.ControlThrowable +import scala.collection.{ mutable, immutable } import symtab._ import Flags._ @@ -817,13 +815,13 @@ abstract class Erasure extends AddInterfaces with typechecker.Analyzer with ast. * with the erased type of <code>m1</code> in the template. * </p> */ - private def bridgeDefs(owner: Symbol): (List[Tree], Set[Symbol]) = { - var toBeRemoved: Set[Symbol] = Set() + private def bridgeDefs(owner: Symbol): (List[Tree], immutable.Set[Symbol]) = { + var toBeRemoved: immutable.Set[Symbol] = immutable.Set() //println("computing bridges for " + owner)//DEBUG assert(phase == currentRun.erasurePhase) val site = owner.thisType val bridgesScope = new Scope - val bridgeTarget = new HashMap[Symbol, Symbol] + val bridgeTarget = new mutable.HashMap[Symbol, Symbol] var bridges: List[Tree] = List() val opc = atPhase(currentRun.explicitOuterPhase) { new overridingPairs.Cursor(owner) { diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 0e8faa1f1e..1403377367 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -9,7 +9,6 @@ package transform import symtab._ import Flags.{ CASE => _, _ } import scala.collection.mutable.ListBuffer -import scala.collection.mutable import matching.{ Patterns, ParallelMatching } /** This class ... diff --git a/src/compiler/scala/tools/nsc/transform/Flatten.scala b/src/compiler/scala/tools/nsc/transform/Flatten.scala index 96c050b51f..512c5fe2bd 100644 --- a/src/compiler/scala/tools/nsc/transform/Flatten.scala +++ b/src/compiler/scala/tools/nsc/transform/Flatten.scala @@ -8,7 +8,8 @@ package transform import symtab._ import Flags._ -import scala.collection.mutable.{HashMap, ListBuffer} +import scala.collection.{ mutable, immutable } +import scala.collection.mutable.ListBuffer abstract class Flatten extends InfoTransform { import global._ @@ -76,7 +77,7 @@ abstract class Flatten extends InfoTransform { class Flattener extends Transformer { /** Buffers for lifted out classes */ - private val liftedDefs = new HashMap[Symbol, ListBuffer[Tree]] + private val liftedDefs = new mutable.HashMap[Symbol, ListBuffer[Tree]] override def transform(tree: Tree): Tree = { tree match { diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index ecf68fa922..034dc04f3c 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -9,7 +9,7 @@ package transform import symtab._ import Flags._ import util.TreeSet -import scala.collection.mutable.{HashMap, LinkedHashMap, ListBuffer} +import scala.collection.mutable.{ LinkedHashMap, ListBuffer } abstract class LambdaLift extends InfoTransform { import global._ diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala index ec283f67fd..98b98b06ac 100644 --- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala +++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala @@ -1,8 +1,7 @@ package scala.tools.nsc -package transform; +package transform -import scala.tools.nsc._ -import scala.collection.mutable.HashMap +import scala.collection.{ mutable, immutable } abstract class LazyVals extends Transform with TypingTransformers with ast.TreeDSL { // inherits abstract value `global' and class `Phase' from Transform @@ -22,7 +21,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD */ class LazyValues(unit: CompilationUnit) extends TypingTransformer(unit) { /** map from method symbols to the number of lazy values it defines. */ - private val lazyVals = new HashMap[Symbol, Int] { + private val lazyVals = new mutable.HashMap[Symbol, Int] { override def default(meth: Symbol) = 0 } @@ -153,7 +152,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD Ident(bmp) === (Ident(bmp) INT_| mask) final val FLAGS_PER_WORD = 32 - val bitmaps = new HashMap[Symbol, List[Symbol]] { + val bitmaps = new mutable.HashMap[Symbol, List[Symbol]] { override def default(meth: Symbol) = Nil } diff --git a/src/compiler/scala/tools/nsc/transform/LiftCode.scala b/src/compiler/scala/tools/nsc/transform/LiftCode.scala index a6a4a8d22c..9438de6390 100644 --- a/src/compiler/scala/tools/nsc/transform/LiftCode.scala +++ b/src/compiler/scala/tools/nsc/transform/LiftCode.scala @@ -8,10 +8,9 @@ package transform import symtab._ import Flags._ -import symtab.Flags._ -import scala.collection.immutable.ListMap -import scala.collection.mutable.{HashMap, ListBuffer} -import scala.tools.nsc.util.{FreshNameCreator, TreeSet} +import scala.collection.{ mutable, immutable } +import scala.collection.mutable.ListBuffer +import scala.tools.nsc.util.FreshNameCreator /** Translate expressions of the form reflect.Code.lift(exp) * to the lifted "reflect trees" representation of exp. @@ -44,7 +43,7 @@ abstract class LiftCode extends Transform with Reifiers { } - type InjectEnvironment = ListMap[reflect.Symbol, Name] + type InjectEnvironment = immutable.ListMap[reflect.Symbol, Name] class Injector(env: InjectEnvironment, fresh: FreshNameCreator) { @@ -109,7 +108,7 @@ abstract class LiftCode extends Transform with Reifiers { def inject(code: reflect.Tree): Tree = - new Injector(ListMap.empty, new FreshNameCreator.Default).inject(code) + new Injector(immutable.ListMap.empty, new FreshNameCreator.Default).inject(code) def codify (tree: Tree): Tree = New(TypeTree(appliedType(definitions.CodeClass.typeConstructor, diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 94e5e2561b..71472e1fcf 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -8,7 +8,8 @@ package transform import symtab._ import Flags._ -import collection.mutable.{ListBuffer, HashMap} +import scala.collection.{ mutable, immutable } +import scala.collection.mutable.ListBuffer abstract class Mixin extends InfoTransform with ast.TreeDSL { import global._ @@ -203,7 +204,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { } /** Map a lazy, mixedin field accessor to it's trait member accessor */ - val initializer = new HashMap[Symbol, Symbol] + val initializer = new mutable.HashMap[Symbol, Symbol] /** Add all members to be mixed in into a (non-trait-) class * These are: diff --git a/src/compiler/scala/tools/nsc/transform/Reifiers.scala b/src/compiler/scala/tools/nsc/transform/Reifiers.scala index eef260f5a3..49ae43e1fe 100644 --- a/src/compiler/scala/tools/nsc/transform/Reifiers.scala +++ b/src/compiler/scala/tools/nsc/transform/Reifiers.scala @@ -1,5 +1,6 @@ package scala.tools.nsc package transform + import scala.tools.nsc.symtab.SymbolTable import scala.reflect import collection.mutable.HashMap diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 89c44654da..efc727a789 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -7,10 +7,7 @@ package scala.tools.nsc package transform import scala.tools.nsc.symtab.Flags -import scala.tools.nsc.util.FreshNameCreator - -import scala.collection.{mutable, immutable} -import immutable.Set +import scala.collection.{ mutable, immutable } /** Specialize code on types. */ @@ -711,7 +708,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { * * there is a valid specialization environment that maps the overridden method type to m's type. */ def needsSpecialOverride(overriding: Symbol, syms: List[Symbol]): (Symbol, TypeEnv) = { - def missingSpecializations(baseTvar: Symbol, derivedTvar: Symbol): Set[Type] = { + def missingSpecializations(baseTvar: Symbol, derivedTvar: Symbol): immutable.Set[Type] = { val baseSet = concreteTypes(baseTvar).toSet val derivedSet = concreteTypes(derivedTvar).toSet baseSet diff derivedSet diff --git a/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala b/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala index de5355de61..61bf972650 100644 --- a/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala +++ b/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala @@ -6,7 +6,7 @@ package scala.tools.nsc package transform -import scala.collection.mutable.{Map, HashMap} +import scala.collection.{ mutable, immutable } /** A base class for transforms. * A transform contains a compiler phase which applies a tree transformer. @@ -26,7 +26,7 @@ trait TypingTransformers { protected def typedPos(pos: Position)(tree: Tree) = localTyper typed { atPos(pos)(tree) } /** a typer for each enclosing class */ - val typers: Map[Symbol, analyzer.Typer] = new HashMap + val typers: mutable.Map[Symbol, analyzer.Typer] = new mutable.HashMap override def atOwner[A](owner: Symbol)(trans: => A): A = atOwner(curTree, owner)(trans) diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 7ca0f089f1..4901ca4d70 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -7,7 +7,7 @@ package scala.tools.nsc package transform import symtab.Flags._ -import scala.collection.mutable.{HashMap, HashSet} +import scala.collection.{ mutable, immutable } /*<export>*/ /** - uncurry all symbol and tree types (@see UnCurryPhase) @@ -152,8 +152,8 @@ abstract class UnCurry extends InfoTransform with TypingTransformers { private var needTryLift = false private var inPattern = false private var inConstructorFlag = 0L - private val byNameArgs = new HashSet[Tree] - private val noApply = new HashSet[Tree] + private val byNameArgs = new mutable.HashSet[Tree] + private val noApply = new mutable.HashSet[Tree] override def transformUnit(unit: CompilationUnit) { freeMutableVars.clear @@ -201,7 +201,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers { appliedType(NonLocalReturnControlClass.typeConstructor, List(argtype)) /** A hashmap from method symbols to non-local return keys */ - private val nonLocalReturnKeys = new HashMap[Symbol, Symbol] + private val nonLocalReturnKeys = new mutable.HashMap[Symbol, Symbol] /** Return non-local return key for given method */ private def nonLocalReturnKey(meth: Symbol) = @@ -700,7 +700,6 @@ abstract class UnCurry extends InfoTransform with TypingTransformers { } } - import collection.mutable /** Set of mutable local variables that are free in some inner method. */ private val freeMutableVars: mutable.Set[Symbol] = new mutable.HashSet diff --git a/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala b/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala index 43ac9182c3..077cc1d057 100644 --- a/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala +++ b/src/compiler/scala/tools/nsc/typechecker/DeVirtualize.scala @@ -7,8 +7,7 @@ package scala.tools.nsc package typechecker import symtab.Flags._ -import transform.{InfoTransform, TypingTransformers} -import scala.tools.nsc.util.{Position, NoPosition} +import transform.{ InfoTransform, TypingTransformers } import scala.collection.mutable.ListBuffer abstract class DeVirtualize extends InfoTransform with TypingTransformers { diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala index dbc3ffbe17..ba827f1421 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala @@ -3,7 +3,7 @@ package typechecker import scala.tools.nsc.symtab.Flags -import scala.collection.{mutable, immutable} +import scala.collection.{ mutable, immutable } /** Duplicate trees and re-type check them, taking care to replace * and create fresh symbols for new local definitions. diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 51ace68ddc..2313822663 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -6,6 +6,7 @@ package scala.tools.nsc package typechecker +import scala.collection.{ mutable, immutable } import scala.collection.mutable.ListBuffer import scala.util.control.ControlThrowable import symtab.Flags._ @@ -78,7 +79,7 @@ trait Infer { * @throws NoInstance */ object instantiate extends TypeMap { - private var excludedVars = scala.collection.immutable.Set[TypeVar]() + private var excludedVars = immutable.Set[TypeVar]() def apply(tp: Type): Type = tp match { case WildcardType | BoundedWildcardType(_) | NoType => throw new NoInstance("undetermined type") diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 3f4ff066d2..472df80df5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -3,17 +3,17 @@ * @author Martin Odersky */ -//todo: rewrite or disllow new T where T is a mixin (currently: <init> not a member of T) +// Added: Sat Oct 7 16:08:21 2006 //todo: use inherited type info also for vars and values + +// Added: Thu Apr 12 18:23:58 2007 //todo: disallow C#D in superclass //todo: treat :::= correctly package scala.tools.nsc package typechecker -import scala.collection.mutable.{HashMap, ListBuffer} -import scala.util.control.ControlThrowable -import scala.tools.nsc.interactive.RangePositions -import scala.tools.nsc.util.{Set, SourceFile, BatchSourceFile} +import scala.collection.mutable.{ HashMap, ListBuffer } +import scala.tools.nsc.util.BatchSourceFile import symtab.Flags._ import util.Statistics diff --git a/src/compiler/scala/tools/nsc/util/Statistics.scala b/src/compiler/scala/tools/nsc/util/Statistics.scala index de51c2778c..9b19f4d6d8 100644 --- a/src/compiler/scala/tools/nsc/util/Statistics.scala +++ b/src/compiler/scala/tools/nsc/util/Statistics.scala @@ -3,7 +3,6 @@ * @author Martin Odersky */ - package scala.tools.nsc package util diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check index b74ba1be0a..4da2386ace 100644 --- a/test/files/jvm/interpreter.check +++ b/test/files/jvm/interpreter.check @@ -180,7 +180,7 @@ scala> <console>:1: error: '=' expected but '=>' found. def x => y => z ^ -scala> <console>:1: error: expected start of definition +scala> <console>:1: error: illegal start of definition [1,2,3] ^ |