diff options
44 files changed, 128 insertions, 1432 deletions
diff --git a/src/compiler/scala/reflect/internal/HasFlags.scala b/src/compiler/scala/reflect/internal/HasFlags.scala index 348f81c51d..0937577ca3 100644 --- a/src/compiler/scala/reflect/internal/HasFlags.scala +++ b/src/compiler/scala/reflect/internal/HasFlags.scala @@ -75,70 +75,41 @@ trait HasFlags { * flag carrying entity. */ def resolveOverloadedFlag(flag: Long): String = Flags.flagToString(flag) - - def privateWithinString = if (hasAccessBoundary) privateWithin.toString else "" - - protected def isSetting(f: Long, mask: Long) = !hasFlag(f) && ((mask & f) != 0L) - protected def isClearing(f: Long, mask: Long) = hasFlag(f) && ((mask & f) != 0L) // Tests which come through cleanly: both Symbol and Modifiers use these // identically, testing for a single flag. - def isCase = hasFlag(CASE ) - def isFinal = hasFlag(FINAL ) - def isImplicit = hasFlag(IMPLICIT ) - def isLazy = hasFlag(LAZY ) - def isMutable = hasFlag(MUTABLE ) // in Modifiers, formerly isVariable - def isOverride = hasFlag(OVERRIDE ) - def isPrivate = hasFlag(PRIVATE ) - def isProtected = hasFlag(PROTECTED) - def isSynthetic = hasFlag(SYNTHETIC) - def isInterface = hasFlag(INTERFACE) - - // Newly introduced based on having a reasonably obvious clean translation. - def isPrivateLocal = hasAllFlags(PrivateLocal) - def isProtectedLocal = hasAllFlags(ProtectedLocal) - def isParamAccessor = hasFlag(PARAMACCESSOR) - def isCaseAccessor = hasFlag(CASEACCESSOR) - def isSuperAccessor = hasFlag(SUPERACCESSOR) - def isLifted = hasFlag(LIFTED) - - // Formerly the Modifiers impl did not include the access boundary check, - // which must have been a bug. - def isPublic = hasNoFlags(PRIVATE | PROTECTED) && !hasAccessBoundary - - // Removed isClass qualification since the flag isn't overloaded and - // sym.isClass is enforced in Namers#validate. - def isSealed = hasFlag(SEALED) - - // Removed !isClass qualification since the flag isn't overloaded. - def isDeferred = hasFlag(DEFERRED) - - // Dropped isTerm condition because flag isn't overloaded. + def hasAbstractFlag = hasFlag(ABSTRACT) + def hasAccessorFlag = hasFlag(ACCESSOR) + def hasDefault = hasAllFlags(DEFAULTPARAM | PARAM) + def hasLocalFlag = hasFlag(LOCAL) + def hasModuleFlag = hasFlag(MODULE) + def hasPackageFlag = hasFlag(PACKAGE) + def hasStableFlag = hasFlag(STABLE) + def hasStaticFlag = hasFlag(STATIC) def isAbstractOverride = hasFlag(ABSOVERRIDE) - def isAnyOverride = hasFlag(OVERRIDE | ABSOVERRIDE) - - // Disambiguating: DEFAULTPARAM, TRAIT - def hasDefault = hasAllFlags(DEFAULTPARAM | PARAM) - def isTrait = hasFlag(TRAIT) && !hasFlag(PARAM) - - // Straightforwardly named accessors already being used differently. - // These names are most likely temporary. - def hasAbstractFlag = hasFlag(ABSTRACT) - def hasAccessorFlag = hasFlag(ACCESSOR) - def hasLocalFlag = hasFlag(LOCAL) - def hasModuleFlag = hasFlag(MODULE) - def hasPackageFlag = hasFlag(PACKAGE) - def hasStableFlag = hasFlag(STABLE) - def hasStaticFlag = hasFlag(STATIC) - - // Disambiguating: LABEL, CONTRAVARIANT, INCONSTRUCTOR - def isLabel = hasAllFlags(LABEL | METHOD) && !hasAccessorFlag - // Cannot effectively disambiguate the others at this level. - def hasContravariantFlag = hasFlag(CONTRAVARIANT) - def hasInConstructorFlag = hasFlag(INCONSTRUCTOR) - - // Name - def isJavaDefined = hasFlag(JAVA) + def isAnyOverride = hasFlag(OVERRIDE | ABSOVERRIDE) + def isCase = hasFlag(CASE) + def isCaseAccessor = hasFlag(CASEACCESSOR) + def isDeferred = hasFlag(DEFERRED) + def isFinal = hasFlag(FINAL) + def isImplicit = hasFlag(IMPLICIT) + def isInterface = hasFlag(INTERFACE) + def isJavaDefined = hasFlag(JAVA) + def isLabel = hasAllFlags(LABEL | METHOD) && !hasAccessorFlag + def isLazy = hasFlag(LAZY) + def isLifted = hasFlag(LIFTED) + def isMutable = hasFlag(MUTABLE) + def isOverride = hasFlag(OVERRIDE) + def isParamAccessor = hasFlag(PARAMACCESSOR) + def isPrivate = hasFlag(PRIVATE) + def isPrivateLocal = hasAllFlags(PrivateLocal) + def isProtected = hasFlag(PROTECTED) + def isProtectedLocal = hasAllFlags(ProtectedLocal) + def isPublic = hasNoFlags(PRIVATE | PROTECTED) && !hasAccessBoundary + def isSealed = hasFlag(SEALED) + def isSuperAccessor = hasFlag(SUPERACCESSOR) + def isSynthetic = hasFlag(SYNTHETIC) + def isTrait = hasFlag(TRAIT) && !hasFlag(PARAM) def flagBitsToString(bits: Long): String = { // Fast path for common case @@ -162,7 +133,7 @@ trait HasFlags { } def accessString: String = { - val pw = privateWithinString + val pw = if (hasAccessBoundary) privateWithin.toString else "" if (pw == "") { if (hasAllFlags(PrivateLocal)) "private[this]" @@ -188,8 +159,6 @@ trait HasFlags { def hasTraitFlag = hasFlag(TRAIT) @deprecated("Use hasDefault", "2.10.0") def hasDefaultFlag = hasFlag(DEFAULTPARAM) - @deprecated("", "2.9.0") - def isAbstract = hasFlag(ABSTRACT) @deprecated("Use isValueParameter or isTypeParameter", "2.10.0") def isParameter = hasFlag(PARAM) @deprecated("Use flagString", "2.10.0") diff --git a/src/compiler/scala/reflect/internal/SymbolCreations.scala b/src/compiler/scala/reflect/internal/SymbolCreations.scala deleted file mode 100644 index ac82ffe62a..0000000000 --- a/src/compiler/scala/reflect/internal/SymbolCreations.scala +++ /dev/null @@ -1,112 +0,0 @@ - /* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.reflect -package internal - -import scala.collection.{ mutable, immutable } -import scala.collection.mutable.ListBuffer -import util.Statistics._ -import Flags._ -import api.Modifier - -trait SymbolCreations { - self: SymbolTable => - - import definitions._ - - /** Symbol creation interface, possibly better moved somewhere else. - * It'd be nice if we had virtual classes, but since we - * don't: these methods insulate the direct instantiation of the symbols - * (which may be overridden, e.g. in SynchronizedSymbols) from the - * enforcement of preconditions and choice of symbol constructor based - * on flags, which are (or should be) final so they can be reasoned about - * without lots of surprises. - */ - trait SymbolCreatorInterface { - // Fallbacks; more precise creators should normally be called. - protected def createTermSymbol(name: TermName, pos: Position, newFlags: Long): TermSymbol - // This in fact does not exist anymore in the interests of better typed TypeSymbols. - // protected def createTypeSymbol(name: TypeName, pos: Position, newFlags: Long): TypeSymbol - - // I believe all but rogue TypeSymbols are one of: ClassSymbol, AbstractTypeSymbol, AliasTypeSymbol, or TypeSkolem. - protected def createAbstractTypeSymbol(name: TypeName, pos: Position, newFlags: Long): AbstractTypeSymbol - protected def createAliasTypeSymbol(name: TypeName, pos: Position, newFlags: Long): AliasTypeSymbol - protected def createTypeSkolemSymbol(name: TypeName, origin: AnyRef, pos: Position, newFlags: Long): TypeSkolem - protected def createClassSymbol(name: TypeName, pos: Position, newFlags: Long): ClassSymbol - - // More specific ClassSymbols. - // TODO - AnonymousClassSymbol. - // TODO maybe - PackageObjects, but that one cost me a lot of time when I tried it before - // because it broke reification some way I couldn't see. - protected def createModuleClassSymbol(name: TypeName, pos: Position, newFlags: Long): ModuleClassSymbol - protected def createPackageClassSymbol(name: TypeName, pos: Position, newFlags: Long): PackageClassSymbol - protected def createRefinementClassSymbol(pos: Position, newFlags: Long): RefinementClassSymbol - protected def createImplClassSymbol(name: TypeName, pos: Position, newFlags: Long): ClassSymbol - protected def createPackageObjectClassSymbol(pos: Position, newFlags: Long): PackageObjectClassSymbol - - // Distinguished term categories include methods, modules, packages, package objects, - // value parameters, and values (including vals, vars, and lazy vals.) - protected def createMethodSymbol(name: TermName, pos: Position, newFlags: Long): MethodSymbol - protected def createModuleSymbol(name: TermName, pos: Position, newFlags: Long): ModuleSymbol - protected def createPackageSymbol(name: TermName, pos: Position, newFlags: Long): PackageSymbol - - // TODO - // protected def createValueParameterSymbol(name: TermName, pos: Position, newFlags: Long): TermSymbol - // protected def createValueMemberSymbol(name: TermName, pos: Position, newFlags: Long): TermSymbol - } - - trait SymbolCreator extends SymbolCreatorInterface { - self: Symbol => - - /*** Predictable symbol creation. - * - * newTermSymbol, newClassSymbol, and newNonClassSymbol all create symbols based - * only on the flags (for reconstruction after reification.) It would be nice to - * combine the last two into newTypeSymbol, but this requires some flag which allows us - * to distinguish classes and type aliases, which as yet does not exist. - * - * The fundamental flags used to determine which Symbol subclass to instantiate are: - * METHOD, PACKAGE, MODULE, PARAM, DEFERRED. - */ - final def newTermSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol = { - if ((newFlags & METHOD) != 0) - createMethodSymbol(name, pos, newFlags) - else if ((newFlags & PACKAGE) != 0) - createPackageSymbol(name, pos, newFlags | PackageFlags) - else if ((newFlags & MODULE) != 0) - createModuleSymbol(name, pos, newFlags) - else if ((newFlags & PARAM) != 0) - createValueParameterSymbol(name, pos, newFlags) - else - createValueMemberSymbol(name, pos, newFlags) - } - - final def newClassSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = { - if (name == tpnme.REFINE_CLASS_NAME) - createRefinementClassSymbol(pos, newFlags) - else if ((newFlags & PACKAGE) != 0) - createPackageClassSymbol(name, pos, newFlags | PackageFlags) - else if (name == tpnme.PACKAGE) - createPackageObjectClassSymbol(pos, newFlags) - else if ((newFlags & MODULE) != 0) - createModuleClassSymbol(name, pos, newFlags) - else if ((newFlags & IMPLCLASS) != 0) - createImplClassSymbol(name, pos, newFlags) - else - createClassSymbol(name, pos, newFlags) - } - - final def newNonClassSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol = { - if ((newFlags & DEFERRED) != 0) - createAbstractTypeSymbol(name, pos, newFlags) - else - createAliasTypeSymbol(name, pos, newFlags) - } - - def newTypeSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol = - newNonClassSymbol(name, pos, newFlags) - } -} diff --git a/src/compiler/scala/reflect/internal/SymbolFlags.scala b/src/compiler/scala/reflect/internal/SymbolFlags.scala deleted file mode 100644 index e14c508fec..0000000000 --- a/src/compiler/scala/reflect/internal/SymbolFlags.scala +++ /dev/null @@ -1,77 +0,0 @@ - /* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.reflect -package internal - -import scala.collection.{ mutable, immutable } -import scala.collection.mutable.ListBuffer -import util.Statistics._ -import Flags._ -import api.Modifier - -trait SymbolFlags { - self: SymbolTable => - - import definitions._ - - trait SymbolFlagLogic { - this: Symbol => - - // Forced for performance reasons to define all the flag manipulation - // methods alongside the field being manipulated. - def getFlag(mask: Long): Long - def hasFlag(mask: Long): Boolean - def hasAllFlags(mask: Long): Boolean - def setFlag(mask: Long): this.type - def resetFlag(mask: Long): this.type - def initFlags(mask: Long): this.type - def resetFlags(): Unit - - protected def resolveOverloadedFlag(flag: Long): String - protected def calculateFlagString(basis: Long): String - - def rawFlagString(mask: Long): String = calculateFlagString(rawflags & mask) - def rawFlagString: String = rawFlagString(flagMask) - def debugFlagString: String = flagString(AllFlags) - - /** String representation of symbol's variance */ - def varianceString: String = - if (variance == 1) "+" - else if (variance == -1) "-" - else "" - - override def flagMask = - if (settings.debug.value && !isAbstractType) AllFlags - else if (owner.isRefinementClass) ExplicitFlags & ~OVERRIDE - else ExplicitFlags - - // make the error message more googlable - def flagsExplanationString = - if (isGADTSkolem) " (this is a GADT skolem)" - else "" - - /** If the given flag is set on this symbol, also set the corresponding - * notFLAG. For instance if flag is PRIVATE, the notPRIVATE flag will - * be set if PRIVATE is currently set. - */ - final def setNotFlag(flag: Int) = if (hasFlag(flag)) setFlag((flag: @annotation.switch) match { - case PRIVATE => notPRIVATE - case PROTECTED => notPROTECTED - case OVERRIDE => notOVERRIDE - case _ => abort("setNotFlag on invalid flag: " + flag) - }) - - def shortSymbolClass = getClass.getName.split('.').last.stripPrefix("Symbols$") - def symbolCreationString: String = ( - "%s%25s | %-40s | %s".format( - if (settings.uniqid.value) "%06d | ".format(id) else "", - shortSymbolClass, - name.decode + " in " + owner, - rawFlagString - ) - ) - } -} diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala index c2f90fff45..ddd6c43031 100644 --- a/src/compiler/scala/reflect/internal/SymbolTable.scala +++ b/src/compiler/scala/reflect/internal/SymbolTable.scala @@ -13,9 +13,7 @@ import scala.tools.nsc.util.WeakHashSet abstract class SymbolTable extends api.Universe with Collections with Names - with SymbolCreations with Symbols - with SymbolFlags with FreeVars with Types with Kinds diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala index 4e12b96ca0..b32b955631 100644 --- a/src/compiler/scala/reflect/internal/Symbols.scala +++ b/src/compiler/scala/reflect/internal/Symbols.scala @@ -157,8 +157,6 @@ trait Symbols extends api.Symbols { self: SymbolTable => abstract class Symbol protected[Symbols] (initOwner: Symbol, initPos: Position, initName: Name) extends AbsSymbolImpl with HasFlags - with SymbolFlagLogic - with SymbolCreator with Annotatable[Symbol] { type AccessBoundaryType = Symbol @@ -208,6 +206,36 @@ trait Symbols extends api.Symbols { self: SymbolTable => } } + def rawFlagString(mask: Long): String = calculateFlagString(rawflags & mask) + def rawFlagString: String = rawFlagString(flagMask) + def debugFlagString: String = flagString(AllFlags) + + /** String representation of symbol's variance */ + def varianceString: String = + if (variance == 1) "+" + else if (variance == -1) "-" + else "" + + override def flagMask = + if (settings.debug.value && !isAbstractType) AllFlags + else if (owner.isRefinementClass) ExplicitFlags & ~OVERRIDE + else ExplicitFlags + + // make the error message more googlable + def flagsExplanationString = + if (isGADTSkolem) " (this is a GADT skolem)" + else "" + + def shortSymbolClass = getClass.getName.split('.').last.stripPrefix("Symbols$") + def symbolCreationString: String = ( + "%s%25s | %-40s | %s".format( + if (settings.uniqid.value) "%06d | ".format(id) else "", + shortSymbolClass, + name.decode + " in " + owner, + rawFlagString + ) + ) + /** !!! The logic after "hasFlag" is far too opaque to be unexplained. * I'm guessing it's attempting to compensate for flag overloading, * and embedding such logic in an undocumented island like this is a @@ -619,15 +647,15 @@ trait Symbols extends api.Symbols { self: SymbolTable => && owner.isPackageClass && nme.isReplWrapperName(name) ) - @inline final override def getFlag(mask: Long): Long = flags & mask + @inline final def getFlag(mask: Long): Long = flags & mask /** Does symbol have ANY flag in `mask` set? */ - @inline final override def hasFlag(mask: Long): Boolean = (flags & mask) != 0 + @inline final def hasFlag(mask: Long): Boolean = (flags & mask) != 0 /** Does symbol have ALL the flags in `mask` set? */ - @inline final override def hasAllFlags(mask: Long): Boolean = (flags & mask) == mask + @inline final def hasAllFlags(mask: Long): Boolean = (flags & mask) == mask - override def setFlag(mask: Long): this.type = { _rawflags |= mask ; this } - override def resetFlag(mask: Long): this.type = { _rawflags &= ~mask ; this } - override def resetFlags() { rawflags &= TopLevelCreationFlags } + def setFlag(mask: Long): this.type = { _rawflags |= mask ; this } + def resetFlag(mask: Long): this.type = { _rawflags &= ~mask ; this } + def resetFlags() { rawflags &= TopLevelCreationFlags } /** Default implementation calls the generic string function, which * will print overloaded flags as <flag1/flag2/flag3>. Subclasses @@ -638,7 +666,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => /** Set the symbol's flags to the given value, asserting * that the previous value was 0. */ - override def initFlags(mask: Long): this.type = { + def initFlags(mask: Long): this.type = { assert(rawflags == 0L, symbolCreationString) _rawflags = mask this @@ -1084,6 +1112,44 @@ trait Symbols extends api.Symbols { self: SymbolTable => protected def createValueMemberSymbol(name: TermName, pos: Position, newFlags: Long): TermSymbol = new TermSymbol(this, pos, name) initFlags newFlags + final def newTermSymbol(name: TermName, pos: Position = NoPosition, newFlags: Long = 0L): TermSymbol = { + if ((newFlags & METHOD) != 0) + createMethodSymbol(name, pos, newFlags) + else if ((newFlags & PACKAGE) != 0) + createPackageSymbol(name, pos, newFlags | PackageFlags) + else if ((newFlags & MODULE) != 0) + createModuleSymbol(name, pos, newFlags) + else if ((newFlags & PARAM) != 0) + createValueParameterSymbol(name, pos, newFlags) + else + createValueMemberSymbol(name, pos, newFlags) + } + + final def newClassSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): ClassSymbol = { + if (name == tpnme.REFINE_CLASS_NAME) + createRefinementClassSymbol(pos, newFlags) + else if ((newFlags & PACKAGE) != 0) + createPackageClassSymbol(name, pos, newFlags | PackageFlags) + else if (name == tpnme.PACKAGE) + createPackageObjectClassSymbol(pos, newFlags) + else if ((newFlags & MODULE) != 0) + createModuleClassSymbol(name, pos, newFlags) + else if ((newFlags & IMPLCLASS) != 0) + createImplClassSymbol(name, pos, newFlags) + else + createClassSymbol(name, pos, newFlags) + } + + final def newNonClassSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol = { + if ((newFlags & DEFERRED) != 0) + createAbstractTypeSymbol(name, pos, newFlags) + else + createAliasTypeSymbol(name, pos, newFlags) + } + + def newTypeSymbol(name: TypeName, pos: Position = NoPosition, newFlags: Long = 0L): TypeSymbol = + newNonClassSymbol(name, pos, newFlags) + /** The class or term up to which this symbol is accessible, * or RootClass if it is public. As java protected statics are * otherwise completely inaccessible in scala, they are treated diff --git a/src/compiler/scala/reflect/internal/TypeDebugging.scala b/src/compiler/scala/reflect/internal/TypeDebugging.scala index 54efef8142..85a1767067 100644 --- a/src/compiler/scala/reflect/internal/TypeDebugging.scala +++ b/src/compiler/scala/reflect/internal/TypeDebugging.scala @@ -50,33 +50,6 @@ trait TypeDebugging { def refine(defs: Scope): String = defs.toList.mkString("{", " ;\n ", "}") } - def dump(tp: Type): Unit = { - println("** " + tp + " / " + tp.getClass + " **") - import tp._ - - println("typeSymbol = " + typeSymbol) - println("termSymbol = " + termSymbol) - println("widen = " + widen) - println("deconst = " + deconst) - println("typeOfThis = " + typeOfThis) - println("bounds = " + bounds) - println("parents = " + parents) - println("prefixChain = " + prefixChain) - println("typeConstructor = " + typeConstructor) - println(" .. typeConstructor.typeParams = " + typeConstructor.typeParams) - println(" .. _.variance = " + (typeConstructor.typeParams map (_.variance))) - println("typeArgs = " + typeArgs) - println("resultType = " + resultType) - println("finalResultType = " + finalResultType) - println("paramss = " + paramss) - println("paramTypes = " + paramTypes) - println("typeParams = " + typeParams) - println("boundSyms = " + boundSyms) - println("baseTypeSeq = " + baseTypeSeq) - println("baseClasses = " + baseClasses) - println("toLongString = " + toLongString) - } - private def debug(tp: Type): String = tp match { case TypeRef(pre, sym, args) => debug(pre) + "." + sym.nameString + str.tparams(args) case ThisType(sym) => sym.nameString + ".this" diff --git a/src/compiler/scala/tools/nsc/Interpreter.scala b/src/compiler/scala/tools/nsc/Interpreter.scala deleted file mode 100644 index 434f19f21b..0000000000 --- a/src/compiler/scala/tools/nsc/Interpreter.scala +++ /dev/null @@ -1,12 +0,0 @@ -package scala.tools.nsc - -import interpreter._ -import java.io._ - -/** A compatibility stub. - */ -@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") -class Interpreter(settings: Settings, out: PrintWriter) extends IMain(settings, out) { - def this(settings: Settings) = this(settings, new NewLinePrintWriter(new ConsoleWriter, true)) - def this() = this(new Settings()) -}
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/InterpreterLoop.scala b/src/compiler/scala/tools/nsc/InterpreterLoop.scala deleted file mode 100644 index a0be3f4fdb..0000000000 --- a/src/compiler/scala/tools/nsc/InterpreterLoop.scala +++ /dev/null @@ -1,12 +0,0 @@ -package scala.tools.nsc - -import interpreter._ -import java.io._ - -/** A compatibility stub. - */ -@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") -class InterpreterLoop(in0: Option[BufferedReader], out: PrintWriter) extends ILoop(in0, out) { - def this(in0: BufferedReader, out: PrintWriter) = this(Some(in0), out) - def this() = this(None, new PrintWriter(scala.Console.out)) -} diff --git a/src/compiler/scala/tools/nsc/MainInterpreter.scala b/src/compiler/scala/tools/nsc/MainInterpreter.scala deleted file mode 100644 index 5d190bbe14..0000000000 --- a/src/compiler/scala/tools/nsc/MainInterpreter.scala +++ /dev/null @@ -1,13 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Lex Spoon - */ - -package scala.tools.nsc - -import interpreter._ - -@deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") -object MainInterpreter { - def main(args: Array[String]): Unit = new ILoop main args -} diff --git a/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala b/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala index 3a605975f4..605ecee6c7 100644 --- a/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/AbstractFileClassLoader.scala @@ -19,11 +19,6 @@ class AbstractFileClassLoader(root: AbstractFile, parent: ClassLoader) extends ClassLoader(parent) with ScalaClassLoader { - // private val defined = mutable.Map[String, Class[_]]() - - override protected def trace = - sys.props contains "scala.debug.classloader" - protected def classNameToPath(name: String): String = if (name endsWith ".class") name else name.replace('.', '/') + ".class" @@ -68,29 +63,13 @@ class AbstractFileClassLoader(root: AbstractFile, parent: ClassLoader) case null => super.classBytes(name) case file => file.toByteArray } - override def loadClass(name: String, resolve: Boolean) = { - classLoaderLog("load " + name + ".") - super.loadClass(name, resolve) - } override def findClass(name: String): JClass = { val bytes = classBytes(name) - classLoaderLog("find %s: %s".format(name, - if (bytes.isEmpty) "failed." - else bytes.size + " bytes." - )) - if (bytes.isEmpty) + if (bytes.length == 0) throw new ClassNotFoundException(name) - else { - val clazz = defineClass(name, bytes, 0, bytes.length) - // defined(name) = clazz - clazz - } + else + defineClass(name, bytes, 0, bytes.length) } - // Don't know how to construct an URL for something which exists only in memory - // override def getResource(name: String): URL = findAbstractFile(name) match { - // case null => super.getResource(name) - // case file => new URL(...) - // } private val packages = mutable.Map[String, Package]() diff --git a/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala b/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala index 453b106808..fc68998225 100644 --- a/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala +++ b/src/compiler/scala/tools/nsc/interpreter/CodeHandlers.scala @@ -17,29 +17,9 @@ import scala.util.control.ControlThrowable trait CodeHandlers[T] { self => -/* - // A declaration introduces names and assigns them types. - // It can form part of a class definition (§5.1) or of a refinement in a compound type (§3.2.7). - // (Ed: aka abstract members.) - // - // ‘val’ ValDcl | ‘var’ VarDcl | ‘def’ FunDcl | ‘type’ {nl} TypeDcl - def decl(code: String): T - - // A definition introduces names that denote terms or types. - // It can form part of an object or class definition or it can be local to a block. - // (Ed: aka concrete members.) - // - // ‘val’ PatDef | ‘var’ VarDef | ‘def’ FunDef | ‘type’ {nl} TypeDef | - // [‘case’] ‘class’ ClassDef | [‘case’] ‘object’ ObjectDef | ‘trait’ TraitDef - def defn(code: String): T -*/ - // Expressions are composed of operators and operands. def expr(code: String): T - // An import clause has the form import p.I where p is a stable identifier (§3.1) and I is an import expression. - def impt(code: String): T - // Statements occur as parts of blocks and templates. // A statement can be an import, a definition or an expression, or it can be empty. // Statements used in the template of a class definition can also be declarations. @@ -54,10 +34,7 @@ trait CodeHandlers[T] { case _: NoSuccess => Nil } - // def decl(code: String) = try Some(self.decl(code)) catch handler - // def defn(code: String) = try Some(self.defn(code)) catch handler def expr(code: String) = try Some(self.expr(code)) catch handler - def impt(code: String) = try Some(self.impt(code)) catch handler def stmt(code: String) = try Some(self.stmt(code)) catch handler def stmts(code: String) = try (self.stmts(code) map (x => Some(x))) catch handlerSeq } diff --git a/src/compiler/scala/tools/nsc/interpreter/Completion.scala b/src/compiler/scala/tools/nsc/interpreter/Completion.scala index 86f48b9d69..7a3e1913b6 100644 --- a/src/compiler/scala/tools/nsc/interpreter/Completion.scala +++ b/src/compiler/scala/tools/nsc/interpreter/Completion.scala @@ -14,13 +14,11 @@ import Completion._ trait Completion { type ExecResult def resetVerbosity(): Unit - def execute(line: String): Option[ExecResult] def completer(): ScalaCompleter } object NoCompletion extends Completion { type ExecResult = Nothing def resetVerbosity() = () - def execute(line: String) = None def completer() = NullCompleter } @@ -44,8 +42,6 @@ object Completion { && !(code startsWith "./") && !(code startsWith "..") ) - private val pathStarts = """/ \ ./ ../ ~/""" split ' ' toSet - def looksLikePath(code: String) = (code != null) && (pathStarts exists (code startsWith _)) object Forwarder { def apply(forwardTo: () => Option[CompletionAware]): CompletionAware = new CompletionAware { def completions(verbosity: Int) = forwardTo() map (_ completions verbosity) getOrElse Nil diff --git a/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala b/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala index c33675a83a..b3bbeb3169 100644 --- a/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala +++ b/src/compiler/scala/tools/nsc/interpreter/CompletionAware.scala @@ -12,40 +12,15 @@ import scala.reflect.NameTransformer * will supply their own candidates and resolve their own paths. */ trait CompletionAware { - /** The delimiters which are meaningful when this CompletionAware - * object is in control. - */ - // TODO - // def delimiters(): List[Char] = List('.') - /** The complete list of unqualified Strings to which this * object will complete. */ def completions(verbosity: Int): List[String] - /** Default filter to apply to completions. - */ - def filterNotFunction(s: String): Boolean = false - - /** Default sort. - */ - def sortFunction(s1: String, s2: String): Boolean = s1 < s2 - - /** Default map. - */ - def mapFunction(s: String) = NameTransformer decode s - /** The next completor in the chain. */ def follow(id: String): Option[CompletionAware] = None - /** What to return if this completion is given as a command. It - * returns None by default, which means to allow the repl to interpret - * the line normally. Returning Some(_) means the line will never - * reach the scala interpreter. - */ - def execute(id: String): Option[Any] = None - /** A list of useful information regarding a specific uniquely * identified completion. This is specifically written for the * following situation, but should be useful elsewhere too: @@ -75,45 +50,13 @@ trait CompletionAware { else comps else follow(parsed.bufferHead) map (_ completionsFor parsed.bufferTail) getOrElse Nil - results filterNot filterNotFunction map mapFunction sortWith (sortFunction _) - } - - /** TODO - unify this and completionsFor under a common traverser. - */ - def executionFor(parsed: Parsed): Option[Any] = { - import parsed._ - - if (isUnqualified && !isLastDelimiter && (completions(verbosity) contains buffer)) execute(buffer) - else if (!isQualified) None - else follow(bufferHead) flatMap (_ executionFor bufferTail) + results.sorted } } object CompletionAware { val Empty = new CompletionAware { def completions(verbosity: Int) = Nil } - /** Artificial object demonstrating completion */ - // lazy val replVars = CompletionAware( - // Map[String, CompletionAware]( - // "ids" -> CompletionAware(() => unqualifiedIds, completionAware _), - // "synthVars" -> CompletionAware(() => allBoundNames filter isSynthVarName map (_.toString)), - // "types" -> CompletionAware(() => allSeenTypes map (_.toString)), - // "implicits" -> CompletionAware(() => allImplicits map (_.toString)) - // ) - // ) - - // class Forwarder(underlying: CompletionAware) extends CompletionAware { - // override def completions() = underlying.completions() - // override def filterNotFunction(s: String) = underlying.filterNotFunction(s) - // override def sortFunction(s1: String, s2: String) = underlying.sortFunction(s1, s2) - // override def mapFunction(s: String) = underlying.mapFunction(s) - // override def follow(id: String) = underlying.follow(id) - // override def execute(id: String) = underlying.execute(id) - // override def completionsFor(parsed: Parsed) = underlying.completionsFor(parsed) - // override def executionFor(parsed: Parsed) = underlying.executionFor(parsed) - // } - // - def unapply(that: Any): Option[CompletionAware] = that match { case x: CompletionAware => Some((x)) case _ => None diff --git a/src/compiler/scala/tools/nsc/interpreter/Eval.scala b/src/compiler/scala/tools/nsc/interpreter/Eval.scala deleted file mode 100644 index 6a59cbb6bf..0000000000 --- a/src/compiler/scala/tools/nsc/interpreter/Eval.scala +++ /dev/null @@ -1,33 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package interpreter - -trait Eval { - /** Executes code looking for an implicit conversion from the type - * of the given identifier to CompletionAware. - */ - // def completionAwareImplicit[T](id: String) = { - // val f1string = "%s => %s".format(typeForIdent(id).get, classOf[CompletionAware].getName) - // val code = """{ - // | def f(implicit x: (%s) = null): %s = x - // | val f1 = f - // | if (f1 == null) None else Some(f1(%s)) - // |}""".stripMargin.format(f1string, f1string, id) - // - // evalExpr[Option[CompletionAware]](code) - // } - - // Coming soon - // implicit def string2liftedcode(s: String): LiftedCode = new LiftedCode(s) - // case class LiftedCode(code: String) { - // val lifted: String = { - // beQuietDuring { interpret(code) } - // eval2[String]("({ " + code + " }).toString") - // } - // def >> : String = lifted - // } -}
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala b/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala index 4a36a4b6f3..79b429e26a 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ExprTyper.scala @@ -32,8 +32,6 @@ trait ExprTyper { def defns(code: String) = stmts(code) collect { case x: DefTree => x } def expr(code: String) = applyRule(code, _.expr()) - def impt(code: String) = applyRule(code, _.importExpr()) - def impts(code: String) = applyRule(code, _.importClause()) def stmts(code: String) = applyRule(code, _.templateStats()) def stmt(code: String) = stmts(code).last // guaranteed nonempty } diff --git a/src/compiler/scala/tools/nsc/interpreter/FileCompletion.scala b/src/compiler/scala/tools/nsc/interpreter/FileCompletion.scala deleted file mode 100644 index e1eb938b3c..0000000000 --- a/src/compiler/scala/tools/nsc/interpreter/FileCompletion.scala +++ /dev/null @@ -1,56 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package interpreter - -/** TODO - * Spaces, dots, and other things in filenames are not correctly handled. - * space-escaping, knowing when we're inside quotes, etc. would be nice. - */ - -import io.{ Directory, Path } - -/** This isn't 100% clean right now, but it works and is simple. Rather - * than delegate to new objects on each '/' in the path, we treat the - * buffer like a path and process it directly. - */ -object FileCompletion { - def executionFor(buffer: String): Option[Path] = { - Some(Directory.Home match { - case Some(d) if buffer startsWith "~" => d / buffer.tail - case _ => Path(buffer) - }) filter (_.exists) - } - - private def fileCompletionForwarder(buffer: String, where: Directory): List[String] = { - completionsFor(where.path + buffer) map (_ stripPrefix where.path) toList - } - - private def homeCompletions(buffer: String): List[String] = { - require(buffer startsWith "~/") - val home = Directory.Home getOrElse (return Nil) - fileCompletionForwarder(buffer.tail, home) map ("~" + _) - } - private def cwdCompletions(buffer: String): List[String] = { - require(buffer startsWith "./") - val cwd = Directory.Current getOrElse (return Nil) - fileCompletionForwarder(buffer.tail, cwd) map ("." + _) - } - - def completionsFor(buffer: String): List[String] = - if (buffer startsWith "~/") homeCompletions(buffer) - else if (buffer startsWith "./") cwdCompletions(buffer) - else { - val p = Path(buffer) - val (dir, stub) = - // don't want /foo/. expanding "." - if (p.name == ".") (p.parent, ".") - else if (p.isDirectory) (p.toDirectory, "") - else (p.parent, p.name) - - dir.list filter (_.name startsWith stub) map (_.path) toList - } -}
\ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala index 4badb90968..f236ee8031 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala @@ -103,16 +103,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) def isAsync = !settings.Yreplsync.value lazy val power = new Power(intp, new StdReplVals(this)) - - // TODO - // object opt extends AestheticSettings - // - @deprecated("Use `intp` instead.", "2.9.0") - def interpreter = intp - - @deprecated("Use `intp` instead.", "2.9.0") - def interpreter_= (i: Interpreter): Unit = intp = i - def history = in.history /** The context class loader at the time this object was created */ @@ -264,14 +254,12 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) cmd("imports", "[name name ...]", "show import history, identifying sources of names", importsCommand), cmd("implicits", "[-v]", "show the implicits in scope", implicitsCommand), cmd("javap", "<path|class>", "disassemble a file or class name", javapCommand), - nullary("keybindings", "show how ctrl-[A-Z] and other keys are bound", keybindingsCommand), cmd("load", "<path>", "load and interpret a Scala file", loadCommand), nullary("paste", "enter paste mode: all input up to ctrl-D compiled together", pasteCommand), nullary("power", "enable power user mode", powerCmd), nullary("quit", "exit the interpreter", () => Result(false, None)), nullary("replay", "reset execution and replay all previous commands", replay), nullary("reset", "reset the repl to its initial state, forgetting all session entries", resetCommand), - // nullary("reset", "reset the interpreter, forgetting session values but retaining session types", replay), shCommand, nullary("silent", "disable/enable automatic printing of results", verbosity), cmd("type", "[-v] <expr>", "display the type of an expression without evaluating it", typeCommand), @@ -280,31 +268,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) /** Power user commands */ lazy val powerCommands: List[LoopCommand] = List( - nullary("dump", "displays a view of the interpreter's internal state", dumpCommand), - nullary("vals", "gives information about the power mode repl vals", valsCommand), - cmd("phase", "<phase>", "set the implicit phase for power commands", phaseCommand), - cmd("wrap", "<method>", "name of method to wrap around each repl line", wrapCommand) withLongHelp (""" - |:wrap - |:wrap clear - |:wrap <method> - | - |Installs a wrapper around each line entered into the repl. - |Currently it must be the simple name of an existing method - |with the specific signature shown in the following example. - | - |def timed[T](body: => T): T = { - | val start = System.nanoTime - | try body - | finally println((System.nanoTime - start) + " nanos elapsed.") - |} - |:wrap timed - | - |If given no argument, :wrap names the wrapper installed. - |An argument of clear will remove the wrapper if any is active. - |Note that wrappers do not compose (a new one replaces the old - |one) and also that the :phase command uses the same machinery, - |so setting :wrap will clear any :phase setting. - """.stripMargin.trim) + cmd("phase", "<phase>", "set the implicit phase for power commands", phaseCommand) ) private def dumpCommand(): Result = { @@ -485,14 +449,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) else res.show() } } - private def keybindingsCommand(): Result = { - if (in.keyBindings.isEmpty) "Key bindings unavailable." - else { - echo("Reading jline properties for default key bindings.") - echo("Accuracy not guaranteed: treat this as a guideline only.\n") - in.keyBindings foreach (x => echo ("" + x)) - } - } + private def wrapCommand(line: String): Result = { def failMsg = "Argument to :wrap must be the name of a method with signature [T](=> T): T" onIntp { intp => @@ -516,10 +473,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) intp setExecutionWrapper intp.pathToTerm(wrapper) "Set wrapper to '" + wrapper + "'" case tp => - failMsg + ( - if (tp == NoType) "\nFound: <unknown>" - else "\nFound: <unknown>" - ) + failMsg + "\nFound: <unknown>" } case _ => failMsg } @@ -528,18 +482,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) private def pathToPhaseWrapper = intp.pathToTerm("$r") + ".phased.atCurrent" private def phaseCommand(name: String): Result = { - // This line crashes us in TreeGen: - // - // if (intp.power.phased set name) "..." - // - // Exception in thread "main" java.lang.AssertionError: assertion failed: ._7.type - // at scala.Predef$.assert(Predef.scala:99) - // at scala.tools.nsc.ast.TreeGen.mkAttributedQualifier(TreeGen.scala:69) - // at scala.tools.nsc.ast.TreeGen.mkAttributedQualifier(TreeGen.scala:44) - // at scala.tools.nsc.ast.TreeGen.mkAttributedRef(TreeGen.scala:101) - // at scala.tools.nsc.ast.TreeGen.mkAttributedStableRef(TreeGen.scala:143) - // - // But it works like so, type annotated. val phased: Phased = power.phased import phased.NoPhaseName @@ -815,10 +757,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) }) } - def runCompletion = - try in.completion execute code map (intp bindSyntheticValue _) - catch { case ex: Exception => None } - /** Here we place ourselves between the user and the interpreter and examine * the input they are ostensibly submitting. We intervene in several cases: * @@ -840,25 +778,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) // line comment, do nothing None } - /** Due to my accidentally letting file completion execution sneak ahead - * of actual parsing this now operates in such a way that the scala - * interpretation always wins. However to avoid losing useful file - * completion I let it fail and then check the others. So if you - * type /tmp it will echo a failure and then give you a Directory object. - * It's not pretty: maybe I'll implement the silence bits I need to avoid - * echoing the failure. - */ - else if (intp isParseable code) { - val (code, result) = reallyInterpret - if (power != null && code == IR.Error) - runCompletion - - result - } - else runCompletion match { - case Some(_) => None // completion hit: avoid the latent error - case _ => reallyInterpret._2 // trigger the latent error - } + else + reallyInterpret._2 } // runs :load `file` on any files passed via -i @@ -937,7 +858,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) /** process command-line arguments and do as they request */ def process(args: Array[String]): Boolean = { - val command = new CommandLine(args.toList, msg => echo("scala: " + msg)) + val command = new CommandLine(args.toList, echo) def neededHelp(): String = (if (command.settings.help.value) command.usageMsg + "\n" else "") + (if (command.settings.Xhelp.value) command.xusageMsg + "\n" else "") @@ -948,16 +869,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) case help => echoNoNL(help) ; true } } - - @deprecated("Use `process` instead", "2.9.0") - def main(args: Array[String]): Unit = { - if (isReplDebug) - System.out.println(new java.util.Date) - - process(args) - } - @deprecated("Use `process` instead", "2.9.0") - def main(settings: Settings): Unit = process(settings) } object ILoop { @@ -1019,32 +930,4 @@ object ILoop { } } def run(lines: List[String]): String = run(lines map (_ + "\n") mkString) - - // provide the enclosing type T - // in order to set up the interpreter's classpath and parent class loader properly - def breakIf[T: ClassTag](assertion: => Boolean, args: NamedParam*): Unit = - if (assertion) break[T](args.toList) - - // start a repl, binding supplied args - def break[T: ClassTag](args: List[NamedParam]): Unit = savingContextLoader { - val msg = if (args.isEmpty) "" else " Binding " + args.size + " value%s.".format( - if (args.size == 1) "" else "s" - ) - echo("Debug repl starting." + msg) - val repl = new ILoop { - override def prompt = "\ndebug> " - } - repl.settings = new Settings(echo) - repl.settings.embeddedDefaults[T] - repl.createInterpreter() - repl.in = new JLineReader(new JLineCompletion(repl)) - - // rebind exit so people don't accidentally call sys.exit by way of predef - repl.quietRun("""def exit = println("Type :quit to resume program execution.")""") - args foreach (p => repl.bind(p.name, p.tpe, p.value)) - repl.loop() - - echo("\nDebug repl exiting.") - repl.closeInterpreter() - } } diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala index c74da69ee9..956e282b26 100644 --- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala +++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala @@ -308,9 +308,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends _classLoader } private class TranslatingClassLoader(parent: ClassLoader) extends AbstractFileClassLoader(virtualDirectory, parent) { - private[IMain] var traceClassLoading = isReplTrace - override protected def trace = super.trace || traceClassLoading - /** Overridden here to try translating a simple name to the generated * class name if the original attempt fails. This method is used by * getResourceAsStream as well as findClass. diff --git a/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala b/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala index 55706f4fd2..241ba5fa4a 100644 --- a/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/InteractiveReader.scala @@ -22,7 +22,6 @@ trait InteractiveReader { def history: History def completion: Completion - def keyBindings: List[KeyBinding] def eraseLine(): Unit def redrawLine(): Unit def currentLine: String diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala b/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala index 795b2e3678..b1e6a9d7d9 100644 --- a/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala +++ b/src/compiler/scala/tools/nsc/interpreter/JLineCompletion.scala @@ -279,24 +279,6 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput if (parsed.isEmpty) xs map ("." + _) else xs } - // chasing down results which won't parse - // This used to work fine, now it reports a type error before any - // exception gets to us. See SI-5657. Don't have time to deal with - // it, so disabling everything. - def execute(line: String): Option[ExecResult] = { - return None // disabled - - val parsed = Parsed(line) - def noDotOrSlash = line forall (ch => ch != '.' && ch != '/') - - if (noDotOrSlash) None // we defer all unqualified ids to the repl. - else { - (ids executionFor parsed) orElse - (rootClass executionFor parsed) orElse - (FileCompletion executionFor line) - } - } - // generic interface for querying (e.g. interpreter loop, testing) def completions(buf: String): List[String] = topLevelFor(Parsed.dotted(buf + ".", buf.length + 1)) @@ -360,15 +342,9 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput if (!looksLikeInvocation(buf)) None else tryCompletion(Parsed.dotted(buf drop 1, cursor), lastResultFor) - def regularCompletion = tryCompletion(mkDotted, topLevelFor) - def fileCompletion = - if (!looksLikePath(buf)) None - else tryCompletion(mkUndelimited, FileCompletion completionsFor _.buffer) - def tryAll = ( lastResultCompletion - orElse regularCompletion - orElse fileCompletion + orElse tryCompletion(mkDotted, topLevelFor) getOrElse Candidates(cursor, Nil) ) diff --git a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala index 99f6b627eb..758f6e2abc 100644 --- a/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/JLineReader.scala @@ -22,9 +22,6 @@ class JLineReader(_completion: => Completion) extends InteractiveReader { lazy val completion = _completion lazy val history: JLineHistory = JLineHistory() - lazy val keyBindings = - try KeyBinding parse slurp(term.getDefaultBindings) - catch { case _: Exception => Nil } private def term = consoleReader.getTerminal() def reset() = term.reset() diff --git a/src/compiler/scala/tools/nsc/interpreter/KeyBinding.scala b/src/compiler/scala/tools/nsc/interpreter/KeyBinding.scala deleted file mode 100644 index a7ca3a77f3..0000000000 --- a/src/compiler/scala/tools/nsc/interpreter/KeyBinding.scala +++ /dev/null @@ -1,39 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package interpreter - -case class KeyBinding(name: String, code: Int, aliases: List[String], description: String) { - def nameString = if (aliases.nonEmpty) aliases mkString ", " else name - override def toString = "%3d %s: %s".format(code, nameString, description) -} - -object KeyBinding { - def parse(bindings: String): List[KeyBinding] = { - def loop(xs: List[String]): List[KeyBinding] = { - val (comment, lines) = xs span (_ startsWith "#") - val description = comment map (_ drop 1 trim) mkString " " - val (aliases, desc) = description span (_ != ':') match { - case (x, y) => ( - x split ',' map (_.trim) toList, - if (y == "") "" else y.tail.trim - ) - } - lines match { - case Nil => Nil - case hd :: tl => - val kb = (hd indexOf '=') match { - case -1 => KeyBinding(hd, -1, aliases, desc) - case idx => KeyBinding(hd drop idx + 1, hd take idx toInt, aliases, desc) - } - kb :: loop(tl) - } - } - // This is verrrrrrrry specific to the current contents - // of the keybindings.properties in jline. - loop(bindings split "\\n" map (_.trim) dropWhile (_ != "") filterNot (_ == "") toList) sortBy (_.code) - } -} diff --git a/src/compiler/scala/tools/nsc/interpreter/ProductCompletion.scala b/src/compiler/scala/tools/nsc/interpreter/ProductCompletion.scala deleted file mode 100644 index dc4582eb17..0000000000 --- a/src/compiler/scala/tools/nsc/interpreter/ProductCompletion.scala +++ /dev/null @@ -1,44 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package interpreter - -class SeqCompletion[T](elems: Seq[T]) extends CompletionAware { - lazy val completions = elems.indices.toList map ("(%d)" format _) - def completions(verbosity: Int) = completions - private def elemAt(name: String) = - if (completions contains name) Some(elems(name drop 1 dropRight 1 toInt)) else None - - override def execute(name: String) = elemAt(name) - override def follow(name: String) = elemAt(name) map (x => ProductCompletion(x)) -} - -/** TODO - deal with non-case products by giving them _1 _2 etc. */ -class ProductCompletion(root: Product) extends CompletionAware { - lazy val caseFields: List[Any] = root.productIterator.toList - lazy val caseNames: List[String] = ByteCode caseParamNamesForPath root.getClass.getName getOrElse Nil - private def isValid = caseFields.length == caseNames.length - - private def fieldForName(s: String) = (completions indexOf s) match { - case idx if idx > -1 && isValid => Some(caseFields(idx)) - case _ => None - } - - lazy val completions = caseNames - def completions(verbosity: Int) = completions - override def execute(name: String) = fieldForName(name) - override def follow(name: String) = fieldForName(name) map (x => ProductCompletion(x)) -} - -object ProductCompletion { - /** TODO: other traversables. */ - def apply(elem: Any): CompletionAware = elem match { - case x: Seq[_] => new SeqCompletion[Any](x) - case x: Product => new ProductCompletion(x) - // case x: Map[_, _] => - case _ => CompletionAware.Empty - } -} diff --git a/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala b/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala index 175f6263ad..0c9f4fcd47 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ReplStrings.scala @@ -11,15 +11,6 @@ import scala.PartialFunction.cond import scala.reflect.internal.Chars trait ReplStrings { - // Longest common prefix - def longestCommonPrefix(xs: List[String]): String = { - if (xs.isEmpty || xs.contains("")) "" - else xs.head.head match { - case ch => - if (xs.tail forall (_.head == ch)) "" + ch + longestCommonPrefix(xs map (_.tail)) - else "" - } - } /** Convert a string into code that can recreate the string. * This requires replacing all special characters by escape * codes. It does not add the surrounding " marks. */ diff --git a/src/compiler/scala/tools/nsc/interpreter/Runner.scala b/src/compiler/scala/tools/nsc/interpreter/Runner.scala deleted file mode 100644 index f9f75da3c6..0000000000 --- a/src/compiler/scala/tools/nsc/interpreter/Runner.scala +++ /dev/null @@ -1,11 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package interpreter - -object Runner { - def main(args: Array[String]): Unit = new ILoop process args -} diff --git a/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala b/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala index 992bef8056..a57b047bc0 100644 --- a/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala +++ b/src/compiler/scala/tools/nsc/interpreter/SimpleReader.scala @@ -18,7 +18,6 @@ extends InteractiveReader { val history = NoHistory val completion = NoCompletion - val keyBindings: List[KeyBinding] = Nil def init() = () def reset() = () diff --git a/src/compiler/scala/tools/nsc/interpreter/XMLCompletion.scala b/src/compiler/scala/tools/nsc/interpreter/XMLCompletion.scala deleted file mode 100644 index 9979814afb..0000000000 --- a/src/compiler/scala/tools/nsc/interpreter/XMLCompletion.scala +++ /dev/null @@ -1,44 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package interpreter - -import xml.{ XML, Group, Node, NodeSeq } -import XMLCompletion._ -import scala.collection.{ mutable, immutable } - -class XMLCompletion(root: Node) extends CompletionAware { - private val nodeCache = new mutable.HashMap[String, Node] - private def getNode(s: String): Option[Node] = { - completions // make sure cache is populated - nodeCache get s - } - - lazy val completions: List[String] = { - def children = root.child.toList - def uniqueTags = children groupBy (_.label) filter (_._2.size == 1) map (_._1) - val uniqs = uniqueTags.toList - - children.foldLeft(List[String]())((res, node) => { - val name = node.label - def count = res filter (_ startsWith (name + "[")) size // ] - val suffix = if (uniqs contains name) "" else "[%d]" format (count + 1) - val s = name + suffix - - nodeCache(s) = node - - s :: res - }).sorted - } - def completions(verbosity: Int) = completions - - override def execute(id: String) = getNode(id) - override def follow(id: String) = getNode(id) map (x => new XMLCompletion(x)) -} - -object XMLCompletion { - def apply(x: Node) = new XMLCompletion(x) -} diff --git a/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala b/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala deleted file mode 100644 index c9ed535841..0000000000 --- a/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala +++ /dev/null @@ -1,44 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2011 LAMP/EPFL - * @author Paul Phillips - */ - -package scala.tools.nsc -package io - -import java.net.{ URL, URLClassLoader } -import java.io.IOException -import collection.JavaConverters._ - -/** A convenience class for finding the jar with the bytecode for - * a given Class object and similar common tasks. - */ -class ClassAndJarInfo[T: ClassTag] { - val tag = classTag[T] - def clazz = tag.erasure - def internalName = clazz.getName.replace('.', '/') - - def resourceURL = new URLClassLoader(Array[URL]()) getResource internalName + ".class" - - def baseOfPath(path: String) = path indexOf '!' match { - case -1 => path stripSuffix internalName + ".class" - case idx => path take idx - } - - def simpleClassName = clazz.getName split """[$.]""" last - def classUrl = clazz getResource simpleClassName + ".class" - def codeSource = protectionDomain.getCodeSource() - def jarManifest = ( - try new JManifest(jarManifestUrl.openStream()) - catch { case _: IOException => new JManifest() } - ) - def jarManifestMainAttrs = jarManifest.getMainAttributes().asScala - def jarManifestUrl = new URL(baseOfPath("" + classUrl) + "!/META-INF/MANIFEST.MF") - def locationFile = File(locationUrl.toURI.getPath()) - def locationUrl = if (codeSource == null) new URL("file:///") else codeSource.getLocation() - def protectionDomain = clazz.getProtectionDomain() - def rootClasspath = rootPossibles find (_.exists) - def rootFromLocation = Path(locationUrl.toURI.getPath()) - def rootFromResource = Path(baseOfPath(classUrl.getPath) stripPrefix "file:") - def rootPossibles = Iterator(rootFromResource, rootFromLocation) -} diff --git a/src/compiler/scala/tools/nsc/package.scala b/src/compiler/scala/tools/nsc/package.scala index a908062b2f..88d600c113 100644 --- a/src/compiler/scala/tools/nsc/package.scala +++ b/src/compiler/scala/tools/nsc/package.scala @@ -6,11 +6,6 @@ package scala.tools package object nsc { - @deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") - type InterpreterSettings = interpreter.ISettings - @deprecated("Use a class in the scala.tools.nsc.interpreter package.", "2.9.0") - val InterpreterResults = interpreter.Results - type Phase = scala.reflect.internal.Phase val NoPhase = scala.reflect.internal.NoPhase diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 8daad8a2ac..9cffb6a1e1 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -149,7 +149,7 @@ abstract class ExplicitOuter extends InfoTransform if (sym.owner.isTrait && ((sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.isModule)) { // 5 sym.makeNotPrivate(sym.owner) } - if (sym.owner.isTrait) sym setNotFlag PROTECTED // 6 + if (sym.owner.isTrait && sym.isProtected) sym setFlag notPROTECTED // 6 if (sym.isClassConstructor && isInner(sym.owner)) { // 1 val p = sym.newValueParameter(innerClassConstructorParamName, sym.pos) .setInfo(sym.owner.outerClass.thisType) @@ -448,8 +448,8 @@ abstract class ExplicitOuter extends InfoTransform override def transform(tree: Tree): Tree = { val sym = tree.symbol if (sym != null && sym.isType) { //(9) - sym setNotFlag PRIVATE - sym setNotFlag PROTECTED + if (sym.isPrivate) sym setFlag notPRIVATE + if (sym.isProtected) sym setFlag notPROTECTED } tree match { case Template(parents, self, decls) => diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala index 48ec941b50..404490bd49 100644 --- a/src/compiler/scala/tools/nsc/util/ClassPath.scala +++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala @@ -9,7 +9,7 @@ package util import java.net.URL import scala.collection.{ mutable, immutable } -import io.{ File, Directory, Path, Jar, AbstractFile, ClassAndJarInfo } +import io.{ File, Directory, Path, Jar, AbstractFile } import scala.tools.util.StringOps.splitWhere import Jar.isJarOrZip import File.pathSeparator @@ -23,16 +23,6 @@ import java.net.MalformedURLException * @author Stepan Koltsov */ object ClassPath { - def scalaLibrary = locate[Option[_]] - def scalaCompiler = locate[Global] - - def infoFor[T](value: T) = info(value.getClass) - def info[T](clazz: Class[T]) = new ClassAndJarInfo()(ClassTag[T](clazz)) - def info[T: ClassTag] = new ClassAndJarInfo[T] - def locate[T: ClassTag] = info[T].rootClasspath - def locateJar[T: ClassTag] = info[T].rootPossibles find (x => isJarOrZip(x)) map (x => File(x)) - def locateDir[T: ClassTag] = info[T].rootPossibles find (_.isDirectory) map (_.toDirectory) - /** Expand single path entry */ private def expandS(pattern: String): List[String] = { val wildSuffix = File.separator + "*" @@ -54,26 +44,6 @@ object ClassPath { else List(pattern) } - /** Return duplicated classpath entries as - * (name, list of origins) - * in the order they occur on the path. - */ - // def findDuplicates(cp: ClassPath[_]) = { - // def toFullName(x: (String, _, cp.AnyClassRep)) = x._1 + "." + x._3.name - // def toOriginString(x: ClassPath[_]) = x.origin getOrElse x.name - // - // /** Flatten everything into tuples, recombine grouped by name, filter down to 2+ entries. */ - // val flattened = ( - // for ((pkgName, pkg) <- cp.allPackagesWithNames ; clazz <- pkg.classes) yield - // (pkgName, pkg, clazz) - // ) - // val multipleAppearingEntries = flattened groupBy toFullName filter (_._2.size > 1) - // - // /** Extract results. */ - // for (name <- flattened map toFullName distinct ; dups <- multipleAppearingEntries get name) yield - // (name, dups map { case (_, cp, _) => toOriginString(cp) }) - // } - /** Split classpath using platform-dependent path separator */ def split(path: String): List[String] = (path split pathSeparator).toList filterNot (_ == "") distinct @@ -240,26 +210,6 @@ abstract class ClassPath[T] { def packages: IndexedSeq[ClassPath[T]] def sourcepaths: IndexedSeq[AbstractFile] - /** Information which entails walking the tree. This is probably only - * necessary for tracking down problems - it's normally not used. - */ - // def allPackages: List[ClassPath[T]] = packages ::: (packages flatMap (_.allPackages)) - // def allPackageNames: List[String] = { - // def subpackages(prefix: String, cp: ClassPath[T]): List[String] = ( - // (cp.packages map (prefix + _.name)) ::: - // (cp.packages flatMap (x => subpackages(prefix + x.name + ".", x))) - // ) - // subpackages("", this) - // } - // def allPackagesWithNames: List[(String, ClassPath[T])] = { - // val root = packages map (p => p.name -> p) - // val subs = - // for ((prefix, p) <- root ; (k, v) <- p.allPackagesWithNames) yield - // (prefix + "." + k, v) - // - // root ::: subs - // } - /** * Represents classes which can be loaded with a ClassfileLoader/MsilFileLoader * and / or a SourcefileLoader. @@ -431,41 +381,10 @@ extends ClassPath[T] { } new MergedClassPath[T](newEntries, context) } - // - // override def allPackages: List[ClassPath[T]] = entries flatMap (_.allPackages) - // override def allPackageNames = entries flatMap (_.allPackageNames) - // override def allPackagesWithNames = entries flatMap (_.allPackagesWithNames) - // - // def duplicatedClasses = { - // def toFullName(x: (String, _, AnyClassRep)) = x._1 + "." + x._3.name - // - // /** Flatten everything into tuples, recombine grouped by name, filter down to 2+ entries. */ - // val flattened = ( - // for ((pkgName, pkg) <- allPackagesWithNames ; clazz <- pkg.classes) yield - // (pkgName, pkg, clazz) - // ) - // val multipleAppearingEntries = flattened groupBy toFullName filter (_._2.size > 1) - // - // /** Using original name list as reference point, return duplicated entries as - // * (name, list of origins) - // * in the order they occur on the path. - // */ - // for (name <- flattened map toFullName distinct ; dups <- multipleAppearingEntries get name) yield - // (name, dups map { - // case (_, cp, _) if cp.origin.isDefined => cp.origin.get - // case (_, cp, _) => cp.asURLs.mkString - // }) - // } - // def show() { println("ClassPath %s has %d entries and results in:\n".format(name, entries.size)) asClasspathString split ':' foreach (x => println(" " + x)) } - // def showDuplicates() = - // ClassPath findDuplicates this foreach { - // case (name, xs) => println(xs.mkString(name + ":\n ", "\n ", "\n")) - // } - // override def toString() = "merged classpath "+ entries.mkString("(", "\n", ")") } diff --git a/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala b/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala index 47f759830e..4c7920d6b3 100644 --- a/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala +++ b/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala @@ -24,14 +24,6 @@ trait HasClassPath { * of java reflection. */ trait ScalaClassLoader extends JClassLoader { - /** Override to see classloader activity traced */ - protected def trace: Boolean = false - protected lazy val classLoaderUniqueId = "Cl#" + System.identityHashCode(this) - protected def classLoaderLog(msg: => String) { - if (trace) - Console.err.println("[" + classLoaderUniqueId + "] " + msg) - } - /** Executing an action with this classloader as context classloader */ def asContext[T](action: => T): T = { val saved = contextLoader @@ -53,18 +45,6 @@ trait ScalaClassLoader extends JClassLoader { def create(path: String): AnyRef = tryToInitializeClass[AnyRef](path) map (_.newInstance()) orNull - override def findClass(name: String) = { - val result = super.findClass(name) - classLoaderLog("findClass(%s) = %s".format(name, result)) - result - } - - override def loadClass(name: String, resolve: Boolean) = { - val result = super.loadClass(name, resolve) - classLoaderLog("loadClass(%s, %s) = %s".format(name, resolve, result)) - result - } - def constructorsOf[T <: AnyRef : ClassTag]: List[Constructor[T]] = classTag[T].erasure.getConstructors.toList map (_.asInstanceOf[Constructor[T]]) @@ -98,7 +78,6 @@ trait ScalaClassLoader extends JClassLoader { case null => Nil case p => p.loaderChain }) - override def toString = classLoaderUniqueId } /** Methods for obtaining various classloaders. @@ -171,7 +150,7 @@ object ScalaClassLoader { classloaderURLs :+= url super.addURL(url) } - def toLongString = urls.mkString("URLClassLoader(id=" + classLoaderUniqueId + "\n ", "\n ", "\n)\n") + def toLongString = urls.mkString("URLClassLoader(\n ", "\n ", "\n)\n") } def fromURLs(urls: Seq[URL], parent: ClassLoader = null): URLClassLoader = diff --git a/src/library/scala/collection/interfaces/IterableMethods.scala b/src/library/scala/collection/interfaces/IterableMethods.scala deleted file mode 100644 index 8efc3fe6f9..0000000000 --- a/src/library/scala/collection/interfaces/IterableMethods.scala +++ /dev/null @@ -1,38 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package interfaces - -import generic._ -import mutable.Buffer -import annotation.unchecked.uncheckedVariance - -/** - * @since 2.8 - */ -trait IterableMethods[+A, +This <: IterableLike[A, This] with Iterable[A]] extends TraversableMethods[A, This] { - self: Iterable[A] => - - // abstract - def iterator: Iterator[A] - - // concrete - def dropRight(n: Int): Iterable[A] - def grouped(size: Int): Iterator[Iterable[A]] - def sameElements[B >: A](that: GenIterable[B]): Boolean - def sliding(size: Int): Iterator[Iterable[A]] - def sliding(size: Int, step: Int): Iterator[Iterable[A]] - def takeRight(n: Int): Iterable[A] - def zipAll[B, A1 >: A, That](that: GenIterable[B], e1: A1, e2: B)(implicit bf: CanBuildFrom[This, (A1, B), That]): That - def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[This, (A1, Int), That]): That - def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[This, (A1, B), That]): That - - override def view: IterableView[A, This] - override def view(from: Int, until: Int): IterableView[A, This] -} diff --git a/src/library/scala/collection/interfaces/MapMethods.scala b/src/library/scala/collection/interfaces/MapMethods.scala deleted file mode 100644 index bc38ccdd2e..0000000000 --- a/src/library/scala/collection/interfaces/MapMethods.scala +++ /dev/null @@ -1,45 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package interfaces - -import generic._ - -/** - * @since 2.8 - */ -trait MapMethods[A, +B, +This <: MapLike[A, B, This] with Map[A, B]] - extends IterableMethods[(A, B), This] - with SubtractableMethods[A, This] { - self: Map[A, B] => - - // abstract - def empty: This - def get(key: A): Option[B] - def iterator: Iterator[(A, B)] - def + [B1 >: B] (kv: (A, B1)): Map[A, B1] - def - (key: A): This - - // concrete - def getOrElse[B1 >: B](key: A, default: => B1): B1 - def apply(key: A): B - def contains(key: A): Boolean - def isDefinedAt(key: A): Boolean - def keys: Iterable[A] - def keysIterator: Iterator[A] - def keySet: Set[A] - def values: Iterable[B] - def valuesIterator: Iterator[B] - def default(key: A): B - def filterKeys(p: A => Boolean): Map[A, B] - def mapValues[C](f: B => C): Map[A, C] - def updated [B1 >: B](key: A, value: B1): Map[A, B1] - def + [B1 >: B] (elem1: (A, B1), elem2: (A, B1), elems: (A, B1) *): Map[A, B1] - def ++[B1 >: B](xs: GenTraversableOnce[(A, B1)]): Map[A, B1] -} diff --git a/src/library/scala/collection/interfaces/SeqMethods.scala b/src/library/scala/collection/interfaces/SeqMethods.scala deleted file mode 100644 index 4327073d21..0000000000 --- a/src/library/scala/collection/interfaces/SeqMethods.scala +++ /dev/null @@ -1,70 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package interfaces - -import generic._ -import mutable.Buffer - -/** - * @since 2.8 - */ -trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMethods[A, This] { - self: Seq[A] => - - // abstract - def apply(idx: Int): A - def length: Int - - // concrete - def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[This, B, That]): That - def :+[B >: A, That](elem: B)(implicit bf: CanBuildFrom[This, B, That]): That - def combinations(n: Int): Iterator[This] - def contains(elem: Any): Boolean - def containsSlice[B](that: Seq[B]): Boolean - def corresponds[B](that: Seq[B])(p: (A,B) => Boolean): Boolean - def diff[B >: A, That](that: Seq[B]): This - def distinct: This - def endsWith[B](that: Seq[B]): Boolean - def indexOfSlice[B >: A](that: Seq[B]): Int - def indexOfSlice[B >: A](that: Seq[B], fromIndex: Int): Int - def indexOf[B >: A](elem: B): Int - def indexOf[B >: A](elem: B, from: Int): Int - def indexWhere(p: A => Boolean): Int - def indexWhere(p: A => Boolean, from: Int): Int - def indices: Range - def intersect[B >: A, That](that: Seq[B]): This - def isDefinedAt(x: Int): Boolean - def lastIndexOfSlice[B >: A](that: Seq[B]): Int - def lastIndexOfSlice[B >: A](that: Seq[B], fromIndex: Int): Int - def lastIndexOf[B >: A](elem: B): Int - def lastIndexOf[B >: A](elem: B, end: Int): Int - def lastIndexWhere(p: A => Boolean): Int - def lastIndexWhere(p: A => Boolean, end: Int): Int - def lengthCompare(len: Int): Int - def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That - def patch[B >: A, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[This, B, That]): That - def permutations: Iterator[This] - def prefixLength(p: A => Boolean): Int - def reverse: This - def reverseIterator: Iterator[A] - def reverseMap[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That - def segmentLength(p: A => Boolean, from: Int): Int - def sortBy[B](f: A => B)(implicit ord: Ordering[B]): This - def sortWith(lt: (A, A) => Boolean): This - def sorted[B >: A](implicit ord: Ordering[B]): This - def startsWith[B](that: Seq[B]): Boolean - def startsWith[B](that: Seq[B], offset: Int): Boolean - def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[This, B, That]): That - def updated[B >: A, That](index: Int, elem: B)(implicit bf: CanBuildFrom[This, B, That]): That - - // refinements - def view: SeqView[A, This] - def view(from: Int, until: Int): SeqView[A, This] -} diff --git a/src/library/scala/collection/interfaces/SetMethods.scala b/src/library/scala/collection/interfaces/SetMethods.scala deleted file mode 100644 index 3b6214f45c..0000000000 --- a/src/library/scala/collection/interfaces/SetMethods.scala +++ /dev/null @@ -1,51 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package interfaces - -import generic._ -import mutable.Buffer -import annotation.unchecked.uncheckedVariance - -/** - * @since 2.8 - */ -trait SubtractableMethods[A, +This <: Subtractable[A, This]] { - def -(elem: A): This - def -(elem1: A, elem2: A, elems: A*): This - def --(xs: TraversableOnce[A]): This -} - -/** - * @since 2.8 - */ -trait SetMethods[A, +This <: SetLike[A, This] with Set[A]] - extends IterableMethods[A, This] - with SubtractableMethods[A, This] { - self: Set[A] => - - // abstract - def empty: This - def contains(elem: A): Boolean - def + (elem: A): This - def - (elem: A): This - - // concrete - def & (that: Set[A]): This - def &~ (that: Set[A]): This - def + (elem1: A, elem2: A, elems: A*): This - def apply(elem: A): Boolean - def diff(that: Set[A]): This - def intersect(that: Set[A]): This - def subsetOf(that: Set[A]): Boolean - def subsets(len: Int): Iterator[This] - def subsets: Iterator[This] - def union(that: Set[A]): This - def | (that: Set[A]): This -} diff --git a/src/library/scala/collection/interfaces/TraversableMethods.scala b/src/library/scala/collection/interfaces/TraversableMethods.scala deleted file mode 100644 index 8aba39093d..0000000000 --- a/src/library/scala/collection/interfaces/TraversableMethods.scala +++ /dev/null @@ -1,63 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package interfaces - -import generic._ - -/** - * @since 2.8 - */ -trait TraversableMethods[+A, +This <: TraversableLike[A, This]] extends TraversableOnceMethods[A] { - self: Traversable[A] => - - // maps/iteration - def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That - def map[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That - def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[This, B, That]): That - def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[This, B, That]): That - def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[This, B, That]): That - - // new collections - def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That - def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[This, B, That]): That - - // element retrieval - def head: A - def headOption: Option[A] - def last: A - def lastOption: Option[A] - - // subcollections - def drop(n: Int): Traversable[A] - def dropWhile(p: A => Boolean): Traversable[A] - def filter(p: A => Boolean): Traversable[A] - def filterNot(p: A => Boolean): Traversable[A] - def init: Traversable[A] - def inits: Iterator[This] - def slice(from: Int, until: Int): Traversable[A] - def tail: Traversable[A] - def tails: Iterator[This] - def take(n: Int): Traversable[A] - def takeWhile(p: A => Boolean): Traversable[A] - def withFilter(p: A => Boolean): FilterMonadic[A, Traversable[A]] - - // subdivisions - def groupBy[K](f: A => K): Map[K, Traversable[A]] - def partition(p: A => Boolean): (Traversable[A], Traversable[A]) - def span(p: A => Boolean): (Traversable[A], Traversable[A]) - def splitAt(n: Int): (Traversable[A], Traversable[A]) - - // info - def stringPrefix: String - - // views - def view: TraversableView[A, This] - def view(from: Int, until: Int): TraversableView[A, This] -} diff --git a/src/library/scala/collection/interfaces/TraversableOnceMethods.scala b/src/library/scala/collection/interfaces/TraversableOnceMethods.scala deleted file mode 100644 index 543d59d118..0000000000 --- a/src/library/scala/collection/interfaces/TraversableOnceMethods.scala +++ /dev/null @@ -1,77 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -package scala.collection -package interfaces - -trait TraversableOnceMethods[+A] { - self: TraversableOnce[A] => - - def foreach[U](f: A => U): Unit - def size: Int - protected[this] def reversed: TraversableOnce[A] - - // tests - def hasDefiniteSize: Boolean - def isEmpty: Boolean - def isTraversableAgain: Boolean - def nonEmpty: Boolean - - // applying a predicate - def collectFirst[B](pf: PartialFunction[A, B]): Option[B] - def count(p: A => Boolean): Int - def exists(p: A => Boolean): Boolean - def find(p: A => Boolean): Option[A] - def forall(p: A => Boolean): Boolean - - // folds - def /:[B](z: B)(op: (B, A) => B): B - def :\[B](z: B)(op: (A, B) => B): B - def foldLeft[B](z: B)(op: (B, A) => B): B - def foldRight[B](z: B)(op: (A, B) => B): B - def reduceLeftOption[B >: A](op: (B, A) => B): Option[B] - def reduceLeft[B >: A](op: (B, A) => B): B - def reduceRightOption[B >: A](op: (A, B) => B): Option[B] - def reduceRight[B >: A](op: (A, B) => B): B - - // copies - def copyToArray[B >: A](xs: Array[B]): Unit - def copyToArray[B >: A](xs: Array[B], start: Int): Unit - def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit - def copyToBuffer[B >: A](dest: mutable.Buffer[B]): Unit - - // conversions - def toArray[B >: A : ArrayTag]: Array[B] - def toBuffer[B >: A]: mutable.Buffer[B] - def toIndexedSeq: immutable.IndexedSeq[A] - def toIterable: Iterable[A] - def toIterator: Iterator[A] - def toList: List[A] - def toMap[T, U](implicit ev: A <:< (T, U)): immutable.Map[T, U] - def toSeq: Seq[A] - def toSet[B >: A]: immutable.Set[B] - def toStream: Stream[A] - def toTraversable: Traversable[A] - - // type-constrained folds - def maxBy[B](f: A => B)(implicit cmp: Ordering[B]): A - def max[B >: A](implicit cmp: Ordering[B]): A - def minBy[B](f: A => B)(implicit cmp: Ordering[B]): A - def min[B >: A](implicit cmp: Ordering[B]): A - def product[B >: A](implicit num: Numeric[B]): B - def sum[B >: A](implicit num: Numeric[B]): B - - // strings - def mkString(start: String, sep: String, end: String): String - def mkString(sep: String): String - def mkString: String - - def addString(buf: StringBuilder, start: String, sep: String, end: String): StringBuilder - def addString(buf: StringBuilder, sep: String): StringBuilder - def addString(buf: StringBuilder): StringBuilder -} diff --git a/test/files/jvm/interpreter.scala b/test/files/jvm/interpreter.scala index 755b2ac9ae..f45eb034a9 100644 --- a/test/files/jvm/interpreter.scala +++ b/test/files/jvm/interpreter.scala @@ -147,7 +147,7 @@ def f(e: Exp) = e match {{ // non-exhaustive warning here def appendix() = { val settings = new Settings settings.classpath.value = sys.props("java.class.path") - val interp = new Interpreter(settings) + val interp = new interpreter.IMain(settings) interp.interpret("def plusOne(x: Int) = x + 1") interp.interpret("plusOne(5)") interp.reset() diff --git a/test/files/run/repl-backticks.scala b/test/files/run/repl-backticks.scala index 11c58e18a1..5eaa1ec4c1 100644 --- a/test/files/run/repl-backticks.scala +++ b/test/files/run/repl-backticks.scala @@ -11,7 +11,7 @@ object Test { def main(args: Array[String]) = { val settings = new Settings() settings.classpath.value = System.getProperty("java.class.path") - val repl = new Interpreter(settings) + val repl = new interpreter.IMain(settings) repl.interpret(testCode) } } diff --git a/test/files/run/repl-suppressed-warnings.check b/test/files/run/repl-suppressed-warnings.check deleted file mode 100644 index ef9e5c1270..0000000000 --- a/test/files/run/repl-suppressed-warnings.check +++ /dev/null @@ -1,65 +0,0 @@ -Type in expressions to have them evaluated. -Type :help for more information. - -scala> - -scala> - -scala> // "Is this thing on?" Not working on first couple - -scala> // commands, needs investigation. - -scala> 123 -res0: Int = 123 - -scala> 123 -res1: Int = 123 - -scala> 123 -res2: Int = 123 - -scala> - -scala> object o { - case class Bippy() - case class Dingus { - def f[T](xs: TraversableOnce[T]) = xs match { - case _: List[Int] => 1 - case _: Set[String] => 2 - case _ => xs.isInstanceOf[Iterator[Double]] - } - } - case class DingDangDoobie(ding: Int, dang: Int, doobie: Double) - case class Dongoo - @serializable case class Heyooooo - - @deprecated("I'm an ironic deprecation warning") def f0 = 5 // where's this disappearing? - def f1 = Double.Epsilon // and this? -} -warning: there were 6 deprecation warnings; re-run with -deprecation for details -warning: there were 3 unchecked warnings; re-run with -unchecked for details -defined module o - -scala> - -scala> :warnings -<console>:3: warning: case classes without a parameter list have been deprecated; -use either case objects or case classes with `()' as parameter list. - case class Dingus { - ^ -<console>:11: warning: case classes without a parameter list have been deprecated; -use either case objects or case classes with `()' as parameter list. - case class Dongoo - ^ -<console>:11: warning: case classes without a parameter list have been deprecated; -use either case objects or case classes with `()' as parameter list. - case class Dongoo - ^ -<console>:12: warning: case classes without a parameter list have been deprecated; -use either case objects or case classes with `()' as parameter list. - @serializable case class Heyooooo - ^ - -scala> - -scala> diff --git a/test/files/run/repl-suppressed-warnings.scala b/test/files/run/repl-suppressed-warnings.scala deleted file mode 100644 index 1a51afe34f..0000000000 --- a/test/files/run/repl-suppressed-warnings.scala +++ /dev/null @@ -1,32 +0,0 @@ -import scala.tools.partest.ReplTest - -object Test extends ReplTest { - override def extraSettings = "" - def code = """ - -// "Is this thing on?" Not working on first couple -// commands, needs investigation. -123 -123 -123 - -object o { - case class Bippy() - case class Dingus { - def f[T](xs: TraversableOnce[T]) = xs match { - case _: List[Int] => 1 - case _: Set[String] => 2 - case _ => xs.isInstanceOf[Iterator[Double]] - } - } - case class DingDangDoobie(ding: Int, dang: Int, doobie: Double) - case class Dongoo - @serializable case class Heyooooo - - @deprecated("I'm an ironic deprecation warning") def f0 = 5 // where's this disappearing? - def f1 = Double.Epsilon // and this? -} - -:warnings - """ -} diff --git a/test/files/run/t1500.scala b/test/files/run/t1500.scala index 586a2666ad..ab132b724f 100644 --- a/test/files/run/t1500.scala +++ b/test/files/run/t1500.scala @@ -1,4 +1,4 @@ -import scala.tools.nsc._ +import scala.tools.nsc._ object Test { @@ -20,7 +20,7 @@ object Test { val settings = new Settings() settings.classpath.value = System.getProperty("java.class.path") - val tool = new Interpreter(settings) + val tool = new interpreter.IMain(settings) val global = tool.compiler import global._ diff --git a/test/files/run/t1501.scala b/test/files/run/t1501.scala index dee6e0c68e..aba206bc7a 100644 --- a/test/files/run/t1501.scala +++ b/test/files/run/t1501.scala @@ -30,7 +30,7 @@ object Test { def main(args: Array[String]) = { val settings = new Settings() settings.classpath.value = System.getProperty("java.class.path") - val tool = new Interpreter(settings) + val tool = new interpreter.IMain(settings) val global = tool.compiler import global._ |