diff options
Diffstat (limited to 'src')
49 files changed, 178 insertions, 117 deletions
diff --git a/src/compiler/scala/reflect/quasiquotes/Reifiers.scala b/src/compiler/scala/reflect/quasiquotes/Reifiers.scala index 8462debe21..b2002a07ea 100644 --- a/src/compiler/scala/reflect/quasiquotes/Reifiers.scala +++ b/src/compiler/scala/reflect/quasiquotes/Reifiers.scala @@ -317,7 +317,7 @@ trait Reifiers { self: Quasiquotes => * Reification of non-trivial list is done in two steps: * * 1. split the list into groups where every placeholder is always - * put in a group of its own and all subsquent non-holeMap are + * put in a group of its own and all subsequent non-holeMap are * grouped together; element is considered to be a placeholder if it's * in the domain of the fill function; * diff --git a/src/compiler/scala/tools/nsc/Properties.scala b/src/compiler/scala/tools/nsc/Properties.scala index ca7d8776d4..cb523edfe5 100644 --- a/src/compiler/scala/tools/nsc/Properties.scala +++ b/src/compiler/scala/tools/nsc/Properties.scala @@ -12,8 +12,16 @@ object Properties extends scala.util.PropertiesTrait { protected def pickJarBasedOn = classOf[Global] // settings based on jar properties, falling back to System prefixed by "scala." + + // messages to display at startup or prompt, format string with string parameters + // Scala version, Java version, JVM name def residentPromptString = scalaPropOrElse("resident.prompt", "\nnsc> ") def shellPromptString = scalaPropOrElse("shell.prompt", "%nscala> ") + def shellWelcomeString = scalaPropOrElse("shell.welcome", + """Welcome to Scala %1$#s (%3$s, Java %2$s). + |Type in expressions for evaluation. Or try :help.""".stripMargin + ) + // message to display at EOF (which by default ends with // a newline so as not to break the user's terminal) def shellInterruptedString = scalaPropOrElse("shell.interrupted", f":quit$lineSeparator") diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala index 0575b9703e..bf53c47e9a 100644 --- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala +++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala @@ -233,7 +233,7 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL { } /** Return the synchronized part of the double-checked locking idiom around the syncBody tree. It guards with `cond` and - * synchronizez on `clazz.this`. Additional statements can be included after initialization, + * synchronizes on `clazz.this`. Additional statements can be included after initialization, * (outside the synchronized block). * * The idiom works only if the condition is using a volatile field. diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala index 076f84ce7a..351a8e33d3 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala @@ -86,7 +86,7 @@ trait Opcodes { self: ICodes => * Each case subclass will represent a specific operation. */ abstract class Instruction extends Cloneable { - // Vlad: I used these for checking the quality of the implementation, and we should regularely run a build with them + // Vlad: I used these for checking the quality of the implementation, and we should regularly run a build with them // enabled. But for production these should definitely be disabled, unless we enjoy getting angry emails from Greg :) //if (!this.isInstanceOf[opcodes.LOAD_EXCEPTION]) // assert(consumed == consumedTypes.length) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 7f0aaa7305..8720da84e8 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -648,7 +648,7 @@ abstract class BTypes { * JVMS 4.7.7: the attribute must be present "if and only if it represents a local class * or an anonymous class" (i.e. not for member classes). * - * The attribute is mis-named, it should be called "EnclosingClass". It has to be defined for all + * The attribute is misnamed, it should be called "EnclosingClass". It has to be defined for all * local and anonymous classes, no matter if there is an enclosing method or not. Accordingly, the * "class" field (see below) must be always defined, while the "method" field may be null. * @@ -798,7 +798,7 @@ abstract class BTypes { * 2. The ClassBType should be built from a classfile, but the class could not be found on the * compilation classpath. * - * Note that all ClassBTypes required in a non-optimzied run are built during code generation from + * Note that all ClassBTypes required in a non-optimized run are built during code generation from * the class symbols referenced by the ASTs, so they have a valid info. Therefore the backend * often invokes `info.get` (which asserts the info to exist) when reading data from the ClassBType. * diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala index 5f8f0e167c..cf29c8090b 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala @@ -355,7 +355,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { // See comment in BTypes, when is a class marked static in the InnerClass table. val isStaticNestedClass = isOriginallyStaticOwner(innerClassSym.originalOwner) - // After lambdalift (which is where we are), the rawowoner field contains the enclosing class. + // After lambdalift (which is where we are), the rawowner field contains the enclosing class. val enclosingClass = { // (1) Example java source: class C { static class D { } } // The Scala compiler creates a class and a module symbol for C. Because D is a static diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 16e8aee1dd..00b4b8b667 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -167,6 +167,11 @@ abstract class GenBCode extends BCodeSyncAndTry { ) } + // shim for SBT, see https://github.com/sbt/sbt/issues/2076 + // TODO put this closer to classfile writing once we have closure elimination + // TODO create a nicer public API to find out the correspondence between sourcefile and ultimate classfiles + currentUnit.icode += new icodes.IClass(cd.symbol) + // -------------- mirror class, if needed -------------- val mirrorC = if (isTopLevelModuleClass(claszSymbol)) { diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index 3d688efae1..bd438f0e75 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -20,7 +20,7 @@ abstract class Reporter extends scala.reflect.internal.Reporter { /** Informational messages. If `!force`, they may be suppressed. */ final def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) - /** For sending a message which should not be labeled as a warning/error, + /** For sending a message which should not be labelled as a warning/error, * but also shouldn't require -verbose to be visible. */ def echo(msg: String): Unit = info(NoPosition, msg, force = true) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala index 9e9372f709..8beb1837ad 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala @@ -40,7 +40,7 @@ trait MatchWarnings { } } - // Issue better warnings than "unreachable code" when people mis-use + // Issue better warnings than "unreachable code" when people misuse // variable patterns thinking they bind to existing identifiers. // // Possible TODO: more deeply nested variable patterns, like diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index c80aaea160..b0bd9977a8 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -550,23 +550,18 @@ trait ContextErrors { def ModuleUsingCompanionClassDefaultArgsErrror(tree: Tree) = NormalTypeError(tree, "module extending its companion class cannot use default constructor arguments") - def NotEnoughArgsError(tree: Tree, fun0: Tree, missing0: List[Symbol]) = { - def notEnoughArgumentsMsg(fun: Tree, missing: List[Symbol]) = { - val suffix = { - if (missing.isEmpty) "" - else { - val keep = missing take 3 map (_.name) - ".\nUnspecified value parameter%s %s".format( - if (missing.tail.isEmpty) "" else "s", - if ((missing drop 3).nonEmpty) (keep :+ "...").mkString(", ") - else keep.mkString("", ", ", ".") - ) - } + def NotEnoughArgsError(tree: Tree, fun: Tree, missing: List[Symbol]) = { + val notEnoughArgumentsMsg = { + val suffix = if (missing.isEmpty) "" else { + val keep = missing take 3 map (_.name) + val ess = if (missing.tail.isEmpty) "" else "s" + f".%nUnspecified value parameter$ess ${ + keep.mkString("", ", ", if ((missing drop 3).nonEmpty) "..." else ".") + }" } - - "not enough arguments for " + treeSymTypeMsg(fun) + suffix + s"not enough arguments for ${ treeSymTypeMsg(fun) }$suffix" } - NormalTypeError(tree, notEnoughArgumentsMsg(fun0, missing0)) + NormalTypeError(tree, notEnoughArgumentsMsg) } //doTypedApply - patternMode @@ -632,12 +627,16 @@ trait ContextErrors { //adapt def MissingArgsForMethodTpeError(tree: Tree, meth: Symbol) = { + val f = meth.name + val paf = s"$f(${ meth.asMethod.paramLists map (_ map (_ => "_") mkString ",") mkString ")(" })" + val advice = s""" + |Unapplied methods are only converted to functions when a function type is expected. + |You can make this conversion explicit by writing `$f _` or `$paf` instead of `$f`.""".stripMargin val message = if (meth.isMacro) MacroTooFewArgumentListsMessage - else "missing arguments for " + meth.fullLocationString + ( - if (meth.isConstructor) "" - else ";\nfollow this method with `_' if you want to treat it as a partially applied function" - ) + else s"""missing argument list for ${meth.fullLocationString}${ + if (!meth.isConstructor) advice else "" + }""" issueNormalTypeError(tree, message) setError(tree) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 7c931600e5..4c840818da 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -1495,7 +1495,7 @@ object ContextMode { final val TypeConstructorAllowed: ContextMode = 1 << 16 /** TODO: The "sticky modes" are EXPRmode, PATTERNmode, TYPEmode. - * To mimick the sticky mode behavior, when captain stickyfingers + * To mimic the sticky mode behavior, when captain stickyfingers * comes around we need to propagate those modes but forget the other * context modes which were once mode bits; those being so far the * ones listed here. diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 3274c86072..7ce945dd6c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -846,7 +846,7 @@ trait Implicits { errors.collectFirst { case err: DivergentImplicitTypeError => err } foreach saveDivergent if (search.isDivergent && divergentError.isEmpty) { - // Divergence triggered by `i` at this level of the implicit serach. We haven't + // Divergence triggered by `i` at this level of the implicit search. We haven't // seen divergence so far, we won't issue this error just yet, and instead temporarily // treat `i` as a failed candidate. saveDivergent(DivergentImplicitTypeError(tree, pt, i.sym)) diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala index f90e32ce8a..f3856db552 100644 --- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala +++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala @@ -436,7 +436,7 @@ trait MethodSynthesis { if (tree.symbol.owner.isTrait || hasUnitType(basisSym)) rhs1 else gen.mkAssignAndReturn(basisSym, rhs1) ) - derivedSym setPos tree.pos // cannot set it at createAndEnterSymbol because basisSym can possible stil have NoPosition + derivedSym setPos tree.pos // cannot set it at createAndEnterSymbol because basisSym can possibly still have NoPosition val ddefRes = DefDef(derivedSym, new ChangeOwnerAndModuleClassTraverser(basisSym, derivedSym)(body)) // ValDef will have its position focused whereas DefDef will have original correct rangepos // ideally positions would be correct at the creation time but lazy vals are really a special case diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 77c49a862a..c1655467e9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -204,7 +204,7 @@ trait Namers extends MethodSynthesis { } // FIXME - this logic needs to be thoroughly explained - // and justified. I know it's wrong with repect to package + // and justified. I know it's wrong with respect to package // objects, but I think it's also wrong in other ways. protected def conflict(newS: Symbol, oldS: Symbol) = ( ( !oldS.isSourceMethod @@ -1106,7 +1106,7 @@ trait Namers extends MethodSynthesis { * As a first side effect, this method assigns a MethodType constructed using this * return type to `meth`. This allows omitting the result type for recursive methods. * - * As another side effect, this method also assigns paramter types from the overridden + * As another side effect, this method also assigns parameter types from the overridden * method to parameters of `meth` that have missing types (the parser accepts missing * parameter types under -Yinfer-argument-types). */ diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala index 8a66c7d274..a702b3cdf5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala @@ -305,7 +305,7 @@ trait PatternTypers { // clearing the type is necessary so that ref will be stabilized; see bug 881 val fun1 = typedPos(fun.pos)(Apply(Select(fun.clearType(), unapplyMethod), unapplyArgTree :: Nil)) - def makeTypedUnApply() = { + def makeTypedUnapply() = { // the union of the expected type and the inferred type of the argument to unapply val glbType = glb(ensureFullyDefined(pt) :: unapplyArg.tpe_* :: Nil) val wrapInTypeTest = canRemedy && !(fun1.symbol.owner isNonBottomSubClass ClassTagClass) @@ -325,7 +325,7 @@ trait PatternTypers { if (isBlackbox(unapplyMethod)) duplErrorTree(BlackboxExtractorExpansion(tree)) else duplErrorTree(WrongShapeExtractorExpansion(tree)) } else - makeTypedUnApply() + makeTypedUnapply() } def wrapClassTagUnapply(uncheckedPattern: Tree, classTagExtractor: Tree, pt: Type): Tree = { diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 059981aa37..5f2643cb25 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -309,6 +309,7 @@ trait TypeDiagnostics { // save the name because it will be mutated until it has been // distinguished from the other types in the same error message private val savedName = sym.name + private var postQualifiedWith: List[Symbol] = Nil def restoreName() = sym.name = savedName def modifyName(f: String => String) = sym setName newTypeName(f(sym.name.toString)) @@ -317,12 +318,12 @@ trait TypeDiagnostics { */ def qualifyDefaultNamespaces() = { val intersect = Set(trueOwner, aliasOwner) intersect UnqualifiedOwners - if (intersect.nonEmpty) preQualify() + if (intersect.nonEmpty && tp.typeSymbolDirect.name == tp.typeSymbol.name) preQualify() } // functions to manipulate the name def preQualify() = modifyName(trueOwner.fullName + "." + _) - def postQualify() = modifyName(_ + "(in " + trueOwner + ")") + def postQualify() = if (!(postQualifiedWith contains trueOwner)) { postQualifiedWith ::= trueOwner; modifyName(_ + "(in " + trueOwner + ")") } def typeQualify() = if (sym.isTypeParameterOrSkolem) postQualify() def nameQualify() = if (trueOwner.isPackageClass) preQualify() else postQualify() diff --git a/src/eclipse/partest/.classpath b/src/eclipse/partest/.classpath index 7e2f119193..de4acf8aa0 100644 --- a/src/eclipse/partest/.classpath +++ b/src/eclipse/partest/.classpath @@ -5,7 +5,7 @@ <classpathentry combineaccessrules="false" kind="src" path="/repl"/> <classpathentry kind="var" path="M2_REPO/com/googlecode/java-diff-utils/diffutils/1.3.0/diffutils-1.3.0.jar"/> <classpathentry kind="var" path="M2_REPO/org/scala-sbt/test-interface/1.0/test-interface-1.0.jar"/> - <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-partest_2.11/1.0.0/scala-partest_2.11-1.0.0.jar"/> + <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-partest_2.12.0-M1/1.0.7/scala-partest_2.12.0-M1-1.0.7.jar"/> <classpathentry kind="var" path="SCALA_BASEDIR/lib/ant/ant.jar"/> <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> <classpathentry combineaccessrules="false" kind="src" path="/scala-compiler"/> diff --git a/src/eclipse/repl/.classpath b/src/eclipse/repl/.classpath index cbaabb9af1..14f7e16670 100644 --- a/src/eclipse/repl/.classpath +++ b/src/eclipse/repl/.classpath @@ -2,7 +2,8 @@ <classpath> <classpathentry kind="src" path="repl"/> <classpathentry combineaccessrules="false" kind="src" path="/asm"/> - <classpathentry kind="var" path="M2_REPO/jline/jline/2.12/jline-2.12.jar"/> + <classpathentry kind="var" path="M2_REPO/jline/jline/2.12.1/jline-2.12.1.jar"/> + <!-- <classpathentry kind="var" path="SCALA_BASEDIR/build/deps/repl/jline-2.12.jar"/> --> <classpathentry combineaccessrules="false" kind="src" path="/scala-compiler"/> <classpathentry combineaccessrules="false" kind="src" path="/scala-library"/> <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> diff --git a/src/eclipse/scaladoc/.classpath b/src/eclipse/scaladoc/.classpath index ee6427176a..2b8282cfb3 100644 --- a/src/eclipse/scaladoc/.classpath +++ b/src/eclipse/scaladoc/.classpath @@ -6,8 +6,8 @@ <classpathentry combineaccessrules="false" kind="src" path="/scala-compiler"/> <classpathentry combineaccessrules="false" kind="src" path="/scala-library"/> <classpathentry combineaccessrules="false" kind="src" path="/partest-extras"/> - <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-xml_2.11/1.0.2/scala-xml_2.11-1.0.2.jar"/> - <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-parser-combinators_2.11/1.0.1/scala-parser-combinators_2.11-1.0.1.jar"/> - <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-partest_2.11/1.0.0/scala-partest_2.11-1.0.0.jar"/> + <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-xml_2.12.0-M1/1.0.4/scala-xml_2.12.0-M1-1.0.4"/> + <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-parser-combinators_2.12.0-M1/1.0.4/scala-parser-combinators_2.12.0-M1-1.0.4.jar"/> + <classpathentry kind="var" path="M2_REPO/org/scala-lang/modules/scala-partest_2.12.0-M1/1.0.7/scala-partest_2.12.0-M1-1.0.7.jar"/> <classpathentry kind="output" path="build-quick-scaladoc"/> </classpath> diff --git a/src/eclipse/test-junit/.classpath b/src/eclipse/test-junit/.classpath index 8a599bd8c7..710d33b030 100644 --- a/src/eclipse/test-junit/.classpath +++ b/src/eclipse/test-junit/.classpath @@ -2,7 +2,7 @@ <classpath> <classpathentry kind="src" path="test-junit"/> <classpathentry kind="var" path="SCALA_BASEDIR/lib/ant/ant.jar"/> - <classpathentry kind="var" path="M2_REPO/junit/junit/4.10/junit-4.10.jar"/> + <classpathentry kind="var" path="M2_REPO/junit/junit/4.11/junit-4.11.jar"/> <classpathentry combineaccessrules="false" kind="src" path="/reflect"/> <classpathentry combineaccessrules="false" kind="src" path="/scala-library"/> <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index 012e7afd74..281e056330 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -82,6 +82,11 @@ object Predef extends LowPriorityImplicits with DeprecatedPredef { */ def classOf[T]: Class[T] = null // This is a stub method. The actual implementation is filled in by the compiler. + /** The `String` type in Scala has methods that come either from the underlying + * Java String (see the documentation corresponding to your Java version, for + * example [[http://docs.oracle.com/javase/8/docs/api/java/lang/String.html]]) or + * are added implicitly through [[scala.collection.immutable.StringOps]]. + */ type String = java.lang.String type Class[T] = java.lang.Class[T] diff --git a/src/library/scala/collection/generic/MutableSortedSetFactory.scala b/src/library/scala/collection/generic/MutableSortedSetFactory.scala index 0339a523e9..9bb12c2317 100644 --- a/src/library/scala/collection/generic/MutableSortedSetFactory.scala +++ b/src/library/scala/collection/generic/MutableSortedSetFactory.scala @@ -24,7 +24,7 @@ abstract class MutableSortedSetFactory[CC[A] <: mutable.SortedSet[A] with Sorted /** * mutable.SetBuilder uses '+' which is not a primitive for anything extending mutable.SetLike, - * this causes serious perfomances issues since each time 'elems = elems + x' + * this causes serious performance issues since each time 'elems = elems + x' * is evaluated elems is cloned (which is O(n)). * * Fortunately GrowingBuilder comes to rescue. diff --git a/src/library/scala/collection/immutable/StringOps.scala b/src/library/scala/collection/immutable/StringOps.scala index 6737692fb1..77333badf9 100644 --- a/src/library/scala/collection/immutable/StringOps.scala +++ b/src/library/scala/collection/immutable/StringOps.scala @@ -12,10 +12,9 @@ package immutable import mutable.StringBuilder -/** - * This class serves as a wrapper providing `String`s with all the operations - * found in indexed sequences. Where needed, instances of `String` object - * are implicitly converted into this class. +/** This class serves as a wrapper providing [[scala.Predef.String]]s with all + * the operations found in indexed sequences. Where needed, `String`s are + * implicitly converted into instances of this class. * * The difference between this class and `WrappedString` is that calling transformer * methods such as `filter` and `map` will yield a `String` object, whereas a diff --git a/src/library/scala/sys/BooleanProp.scala b/src/library/scala/sys/BooleanProp.scala index e5e4668edb..b0008b41fd 100644 --- a/src/library/scala/sys/BooleanProp.scala +++ b/src/library/scala/sys/BooleanProp.scala @@ -50,6 +50,7 @@ object BooleanProp { def get: String = "" + value val clear, enable, disable, toggle = () def option = if (isSet) Some(value) else None + //def or[T1 >: Boolean](alt: => T1): T1 = if (value) true else alt protected def zero = false } diff --git a/src/library/scala/sys/Prop.scala b/src/library/scala/sys/Prop.scala index 17ae8cb69c..52a3d89ecb 100644 --- a/src/library/scala/sys/Prop.scala +++ b/src/library/scala/sys/Prop.scala @@ -58,6 +58,10 @@ trait Prop[+T] { */ def option: Option[T] + // Do not open until 2.12. + //** This value if the property is set, an alternative value otherwise. */ + //def or[T1 >: T](alt: => T1): T1 + /** Removes the property from the underlying map. */ def clear(): Unit diff --git a/src/manual/scala/tools/docutil/ManMaker.scala b/src/manual/scala/tools/docutil/ManMaker.scala index 47b861a80f..802b357f5f 100644 --- a/src/manual/scala/tools/docutil/ManMaker.scala +++ b/src/manual/scala/tools/docutil/ManMaker.scala @@ -18,7 +18,7 @@ class ManMaker extends Task { /** The directory to put html pages in */ private var htmlout: Option[File] = None - /** The directory to put man pags in */ + /** The directory to put man pages in */ private var manout: Option[File] = None diff --git a/src/partest-extras/scala/tools/partest/ASMConverters.scala b/src/partest-extras/scala/tools/partest/ASMConverters.scala index f6e2d2a9ec..90f314428b 100644 --- a/src/partest-extras/scala/tools/partest/ASMConverters.scala +++ b/src/partest-extras/scala/tools/partest/ASMConverters.scala @@ -131,7 +131,7 @@ object ASMConverters { import collection.mutable.{Map => MMap} /** - * Bytecode is equal modula local variable numbering and label numbering. + * Bytecode is equal modulo local variable numbering and label numbering. */ def equivalentBytecode(as: List[Instruction], bs: List[Instruction], varMap: MMap[Int, Int] = MMap(), labelMap: MMap[Int, Int] = MMap()): Boolean = { def same(v1: Int, v2: Int, m: MMap[Int, Int]) = { diff --git a/src/partest-extras/scala/tools/partest/ReplTest.scala b/src/partest-extras/scala/tools/partest/ReplTest.scala index 1fde2370d3..20dfe0eb16 100644 --- a/src/partest-extras/scala/tools/partest/ReplTest.scala +++ b/src/partest-extras/scala/tools/partest/ReplTest.scala @@ -6,8 +6,9 @@ package scala.tools.partest import scala.tools.nsc.Settings -import scala.tools.nsc.interpreter.ILoop +import scala.tools.nsc.interpreter.{ ILoop, replProps } import java.lang.reflect.{ Method => JMethod, Field => JField } +import scala.util.matching.Regex import scala.util.matching.Regex.Match /** A class for testing repl code. @@ -19,30 +20,33 @@ abstract class ReplTest extends DirectTest { // final because we need to enforce the existence of a couple settings. final override def settings: Settings = { val s = super.settings - // s.Yreplsync.value = true s.Xnojline.value = true transformSettings(s) } + def normalize(s: String) = s /** True for SessionTest to preserve session text. */ def inSession: Boolean = false - /** True to preserve welcome text. */ + /** True to preserve welcome header, eliding version number. */ def welcoming: Boolean = false - lazy val welcome = "(Welcome to Scala) version .*".r - def normalize(s: String) = s match { - case welcome(w) => w - case s => s - } - def unwelcoming(s: String) = s match { - case welcome(w) => false - case _ => true - } + lazy val header = replProps.welcome def eval() = { val s = settings log("eval(): settings = " + s) - //ILoop.runForTranscript(code, s).lines drop 1 // not always first line val lines = ILoop.runForTranscript(code, s, inSession = inSession).lines - if (welcoming) lines map normalize - else lines filter unwelcoming + (if (welcoming) { + val welcome = "(Welcome to Scala).*".r + //val welcome = Regex.quote(header.lines.next).r + //val version = "(.*version).*".r // version on separate line? + //var inHead = false + lines map { + //case s @ welcome() => inHead = true ; s + //case version(s) if inHead => inHead = false ; s + case welcome(s) => s + case s => s + } + } else { + lines drop header.lines.size + }) map normalize } def show() = eval() foreach println } diff --git a/src/reflect/scala/reflect/api/Internals.scala b/src/reflect/scala/reflect/api/Internals.scala index 577cd09295..1457fdc133 100644 --- a/src/reflect/scala/reflect/api/Internals.scala +++ b/src/reflect/scala/reflect/api/Internals.scala @@ -114,7 +114,7 @@ trait Internals { self: Universe => def substituteTypes(tree: Tree, from: List[Symbol], to: List[Type]): Tree /** Substitute given tree `to` for occurrences of nodes that represent - * `C.this`, where `C` referes to the given class `clazz`. + * `C.this`, where `C` refers to the given class `clazz`. */ def substituteThis(tree: Tree, clazz: Symbol, to: Tree): Tree diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index 3647d516a8..3552eb1713 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -103,7 +103,7 @@ trait Definitions extends api.StandardDefinitions { def isNumericValueClass(sym: Symbol) = ScalaNumericValueClasses contains sym def isGetClass(sym: Symbol) = ( - sym.name == nme.getClass_ // this condition is for performance only, this is called from `Typer#stabliize`. + sym.name == nme.getClass_ // this condition is for performance only, this is called from `Typer#stabilize`. && getClassMethods(sym) ) diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala index 26e3cf6d0b..f1016e1b76 100644 --- a/src/reflect/scala/reflect/internal/StdNames.scala +++ b/src/reflect/scala/reflect/internal/StdNames.scala @@ -871,7 +871,7 @@ trait StdNames { val toFloat: NameType = "toFloat" val toDouble: NameType = "toDouble" - // primitive operation methods for structual types mostly + // primitive operation methods for structural types mostly // overlap with the above, but not for these two. val toCharacter: NameType = "toCharacter" val toInteger: NameType = "toInteger" diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index 6ded3bcbe3..9c681f3423 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -925,7 +925,7 @@ trait Types def prefixString = trimPrefix(toString) + "#" /** Convert toString avoiding infinite recursions by cutting off - * after `maxTostringRecursions` recursion levels. Uses `safeToString` + * after `maxToStringRecursions` recursion levels. Uses `safeToString` * to produce a string on each level. */ override final def toString: String = { @@ -1496,7 +1496,7 @@ trait Types } finally { if (Statistics.canEnable) Statistics.popTimer(typeOpsStack, start) } - // [Martin] suppressing memo-ization solves the problem with "same type after erasure" errors + // [Martin] suppressing memoization solves the problem with "same type after erasure" errors // when compiling with // scalac scala.collection.IterableViewLike.scala scala.collection.IterableLike.scala // I have not yet figured out precisely why this is the case. @@ -2602,7 +2602,7 @@ trait Types * based on the bounds of the type parameters of the quantified type * In Scala syntax, given a java-defined class C[T <: String], the existential type C[_] * is improved to C[_ <: String] before skolemization, which captures (get it?) what Java does: - * enter the type paramers' bounds into the context when checking subtyping/type equality of existential types + * enter the type parameters' bounds into the context when checking subtyping/type equality of existential types * * Also tried doing this once during class file parsing or when creating the existential type, * but that causes cyclic errors because it happens too early. @@ -4277,7 +4277,7 @@ trait Types matchesType(res1, res2.substSym(tparams2, tparams1), alwaysMatchSimple) (tp1, tp2) match { case (MethodType(params1, res1), MethodType(params2, res2)) => - params1.length == params2.length && // useful pre-secreening optimization + params1.length == params2.length && // useful pre-screening optimization matchingParams(params1, params2, tp1.isInstanceOf[JavaMethodType], tp2.isInstanceOf[JavaMethodType]) && matchesType(res1, res2, alwaysMatchSimple) && tp1.isImplicit == tp2.isImplicit diff --git a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala index f79099213a..e321a07f51 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala @@ -99,7 +99,7 @@ private[internal] trait TypeConstraints { // a lower bound despite the fact that Nothing is always a lower bound. My current // supposition is that the side-effecting type constraint accumulation mechanism // depends on these subtype tests being performed to make forward progress when - // there are mutally recursive type vars. + // there are mutually recursive type vars. // See pos/t6367 and pos/t6499 for the competing test cases. val mustConsider = tp.typeSymbol match { case NothingClass => true diff --git a/src/reflect/scala/reflect/macros/FrontEnds.scala b/src/reflect/scala/reflect/macros/FrontEnds.scala index a770f325b2..8ad41382a8 100644 --- a/src/reflect/scala/reflect/macros/FrontEnds.scala +++ b/src/reflect/scala/reflect/macros/FrontEnds.scala @@ -12,7 +12,7 @@ package macros trait FrontEnds { self: blackbox.Context => - /** For sending a message which should not be labeled as a warning/error, + /** For sending a message which should not be labelled as a warning/error, * but also shouldn't require -verbose to be visible. * Use `enclosingPosition` if you're in doubt what position to pass to `pos`. */ diff --git a/src/reflect/scala/reflect/runtime/SymbolTable.scala b/src/reflect/scala/reflect/runtime/SymbolTable.scala index 092bbd711f..eee2118898 100644 --- a/src/reflect/scala/reflect/runtime/SymbolTable.scala +++ b/src/reflect/scala/reflect/runtime/SymbolTable.scala @@ -3,7 +3,7 @@ package reflect package runtime /** - * This symbol table trait fills in the definitions so that class information is obtained by refection. + * This symbol table trait fills in the definitions so that class information is obtained by reflection. * It can be used either from a reflexive universe (class scala.reflect.runtime.JavaUniverse), or else from * a runtime compiler that uses reflection to get a class information (class scala.tools.reflect.ReflectGlobal) */ diff --git a/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala b/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala index 9bcf85dd6f..1d02cc7e89 100644 --- a/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala +++ b/src/reflect/scala/reflect/runtime/SynchronizedTypes.scala @@ -82,9 +82,9 @@ private[reflect] trait SynchronizedTypes extends internal.Types { self: SymbolTa override def toStringSubjects = _toStringSubjects.get /* The idea of caches is as follows. - * When in reflexive mode, a cache is either null, or one sentinal + * When in reflexive mode, a cache is either null, or one sentinel * value representing undefined or the final defined - * value. Hence, we can ask in non-synchronized ode whether the cache field + * value. Hence, we can ask in non-synchronized mode whether the cache field * is non null and different from the sentinel (if a sentinel exists). * If that's true, the cache value is current. * Otherwise we arrive in one of the defined... methods listed below diff --git a/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala b/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala index b6c9792ec0..53a06ca972 100644 --- a/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala +++ b/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala @@ -7,9 +7,9 @@ package scala.tools.nsc.interpreter.jline import _root_.jline.console.history.PersistentHistory - import scala.tools.nsc.interpreter -import scala.tools.nsc.io.{File, Path} +import scala.reflect.io.{ File, Path } +import scala.tools.nsc.Properties.{ propOrNone, userHome } /** TODO: file locking. */ @@ -85,9 +85,9 @@ object FileBackedHistory { // val ContinuationChar = '\003' // val ContinuationNL: String = Array('\003', '\n').mkString - import scala.tools.nsc.Properties.userHome - - def defaultFileName = ".scala_history" + final val defaultFileName = ".scala_history" - def defaultFile: File = File(Path(userHome) / defaultFileName) + def defaultFile: File = File( + propOrNone("scala.shell.histfile") map (Path.apply) getOrElse (Path(userHome) / defaultFileName) + ) } diff --git a/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala b/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala index 1f6a1f7022..3bc259252a 100644 --- a/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala +++ b/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala @@ -15,7 +15,7 @@ import scala.tools.nsc.interpreter import scala.tools.nsc.interpreter.session.{History, SimpleHistory} -/** A straight scalification of the jline interface which mixes +/** A straight scalafication of the jline interface which mixes * in the sparse jline-independent one too. */ trait JLineHistory extends JHistory with History { diff --git a/src/repl/scala/tools/nsc/interpreter/Formatting.scala b/src/repl/scala/tools/nsc/interpreter/Formatting.scala index 844997429c..4a9548730a 100644 --- a/src/repl/scala/tools/nsc/interpreter/Formatting.scala +++ b/src/repl/scala/tools/nsc/interpreter/Formatting.scala @@ -30,3 +30,6 @@ class Formatting(indent: Int) { } ) } +object Formatting { + def forPrompt(prompt: String) = new Formatting(prompt.lines.toList.last.length) +} diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala index e8c6d02d1e..612bdd98c9 100644 --- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala @@ -56,13 +56,9 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) private var globalFuture: Future[Boolean] = _ - /** Print a welcome message */ - def printWelcome() { - echo(s""" - |Welcome to Scala $versionString ($javaVmName, Java $javaVersion). - |Type in expressions to have them evaluated. - |Type :help for more information.""".trim.stripMargin - ) + /** Print a welcome message! */ + def printWelcome(): Unit = { + Option(replProps.welcome) filter (!_.isEmpty) foreach echo replinfo("[info] started at " + new java.util.Date) } @@ -111,10 +107,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } class ILoopInterpreter extends IMain(settings, out) { - // the expanded prompt but without color escapes and without leading newline, for purposes of indenting - override lazy val formatting: Formatting = new Formatting( - (replProps.promptString format Properties.versionNumberString).lines.toList.last.length - ) override protected def parentClassLoader = settings.explicitParentLoader.getOrElse( classOf[ILoop].getClassLoader ) } @@ -679,9 +671,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } def verbosity() = { - val old = intp.printResults - intp.printResults = !old - echo("Switched " + (if (old) "off" else "on") + " result printing.") + intp.printResults = !intp.printResults + replinfo(s"Result printing is ${ if (intp.printResults) "on" else "off" }.") } /** Run one command submitted by the user. Two values are returned: @@ -761,7 +752,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) private object paste extends Pasted { import scala.util.matching.Regex.quote - val ContinueString = " | " + val ContinuePrompt = replProps.continuePrompt + val ContinueString = replProps.continueText // " | " val PromptString = prompt.lines.toList.last val anyPrompt = s"""\\s*(?:${quote(PromptString.trim)}|${quote(AltPromptString.trim)})\\s*""".r @@ -805,7 +797,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) echo("You typed two blank lines. Starting a new command.") None case IR.Incomplete => - in.readLine(paste.ContinueString) match { + in.readLine(paste.ContinuePrompt) match { case null => // we know compilation is going to fail since we're at EOF and the // parser thinks the input is still incomplete, but since this is @@ -948,8 +940,9 @@ object ILoop { Console.withOut(ostream) { val output = new JPrintWriter(new OutputStreamWriter(ostream), true) { // skip margin prefix for continuation lines, unless preserving session text for test + // should test for repl.paste.ContinueString or replProps.continueText.contains(ch) override def write(str: String) = - if (!inSession && (str forall (ch => ch.isWhitespace || ch == '|'))) () // repl.paste.ContinueString + if (!inSession && (str forall (ch => ch.isWhitespace || ch == '|'))) () else super.write(str) } val input = new BufferedReader(new StringReader(code.trim + "\n")) { diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala index 2550a5dc57..841b4abfa5 100644 --- a/src/repl/scala/tools/nsc/interpreter/IMain.scala +++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala @@ -113,9 +113,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set def this() = this(new Settings()) // the expanded prompt but without color escapes and without leading newline, for purposes of indenting - lazy val formatting: Formatting = new Formatting( - (replProps.promptString format Properties.versionNumberString).lines.toList.last.length - ) + lazy val formatting = Formatting.forPrompt(replProps.promptText) lazy val reporter: ReplReporter = new ReplReporter(this) import formatting.indentCode diff --git a/src/repl/scala/tools/nsc/interpreter/Pasted.scala b/src/repl/scala/tools/nsc/interpreter/Pasted.scala index 5f388eb15b..f8d8c2ddb1 100644 --- a/src/repl/scala/tools/nsc/interpreter/Pasted.scala +++ b/src/repl/scala/tools/nsc/interpreter/Pasted.scala @@ -21,7 +21,13 @@ abstract class Pasted { def PromptString: String def AltPromptString: String = "scala> " - private val testBoth = PromptString != AltPromptString + /* `testBoth` cannot be a val, as `Pasted` is inherited by `object paste` in ILoop, + which would cause `val testBoth` to be initialized before `val PromptString` was. + + object paste extends Pasted { + val PromptString = prompt.lines.toList.last + */ + private def testBoth = PromptString != AltPromptString private val spacey = " \t".toSet def matchesPrompt(line: String) = matchesString(line, PromptString) || testBoth && matchesString(line, AltPromptString) diff --git a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala index df65e9974d..588d92f81b 100644 --- a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala +++ b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala @@ -6,9 +6,11 @@ package scala.tools.nsc package interpreter -import Properties.shellPromptString +import Properties.{ javaVersion, javaVmName, shellPromptString, shellWelcomeString, + versionString, versionNumberString } import scala.sys._ import Prop._ +import java.util.{ Formattable, FormattableFlags, Formatter } class ReplProps { private def bool(name: String) = BooleanProp.keyExists(name) @@ -22,12 +24,44 @@ class ReplProps { val trace = bool("scala.repl.trace") val power = bool("scala.repl.power") - // Handy system prop for shell prompt, or else pick it up from compiler.properties - val promptString = Prop[String]("scala.repl.prompt").option getOrElse (if (info) "%nscala %s> " else shellPromptString) - val prompt = { + def enversion(s: String) = { + import FormattableFlags._ + val v = new Formattable { + override def formatTo(formatter: Formatter, flags: Int, width: Int, precision: Int) = { + val version = if ((flags & ALTERNATE) != 0) versionNumberString else versionString + val left = if ((flags & LEFT_JUSTIFY) != 0) "-" else "" + val w = if (width >= 0) s"$width" else "" + val p = if (precision >= 0) s".$precision" else "" + val fmt = s"%${left}${w}${p}s" + formatter.format(fmt, version) + } + } + s.format(v, javaVersion, javaVmName) + } + def encolor(s: String) = { import scala.io.AnsiColor.{ MAGENTA, RESET } - val p = promptString format Properties.versionNumberString - if (colorOk) s"$MAGENTA$p$RESET" else p + if (colorOk) s"$MAGENTA$s$RESET" else s + } + + // Handy system prop for shell prompt, or else pick it up from compiler.properties + val promptString = Prop[String]("scala.repl.prompt").option getOrElse (if (info) "%nscala %#s> " else shellPromptString) + val promptText = enversion(promptString) + val prompt = encolor(promptText) + + // Prompt for continued input, will be right-adjusted to width of the primary prompt + val continueString = Prop[String]("scala.repl.continue").option getOrElse "| " + val continueText = { + val text = enversion(continueString) + val margin = promptText.lines.toList.last.length - text.length + if (margin > 0) " " * margin + text else text + } + val continuePrompt = encolor(continueText) + + // Next time. + //def welcome = enversion(Prop[String]("scala.repl.welcome") or shellWelcomeString) + def welcome = enversion { + val p = Prop[String]("scala.repl.welcome") + if (p.isSet) p.get else shellWelcomeString } /** CSV of paged,across to enable pagination or `-x` style diff --git a/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala index f853df0484..9de6ec4ab9 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala @@ -114,7 +114,7 @@ trait MemberLookupBase { // Maintaining compatibility with previous links is a bit tricky here: // we have a preference for term names for all terms except for the last, where we prefer a class: // How to do this: - // - at each step we do a DFS search with the prefered strategy + // - at each step we do a DFS search with the preferred strategy // - if the search doesn't return any members, we backtrack on the last decision // * we look for terms with the last member's name // * we look for types with the same name, all the way up diff --git a/src/scaladoc/scala/tools/nsc/doc/base/comment/Comment.scala b/src/scaladoc/scala/tools/nsc/doc/base/comment/Comment.scala index a3d05ae50b..e5eb68d65a 100644 --- a/src/scaladoc/scala/tools/nsc/doc/base/comment/Comment.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/comment/Comment.scala @@ -93,7 +93,7 @@ abstract class Comment { def todo: List[Body] /** Whether the entity is deprecated. Using the `@deprecated` Scala attribute - * is prefereable to using this Scaladoc tag. */ + * is preferable to using this Scaladoc tag. */ def deprecated: Option[Body] /** An additional note concerning the contract of the entity. */ diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramStats.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramStats.scala index ab8e9e2756..12c609af49 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramStats.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramStats.scala @@ -36,7 +36,7 @@ object DiagramStats { private[this] val filterTrack = new TimeTracker("diagrams model filtering") private[this] val modelTrack = new TimeTracker("diagrams model generation") private[this] val dotGenTrack = new TimeTracker("dot diagram generation") - private[this] val dotRunTrack = new TimeTracker("dot process runnning") + private[this] val dotRunTrack = new TimeTracker("dot process running") private[this] val svgTrack = new TimeTracker("svg processing") private[this] var brokenImages = 0 private[this] var fixedImages = 0 diff --git a/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala b/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala index 90de51d763..d55c51b19c 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala @@ -183,7 +183,7 @@ trait MemberEntity extends Entity { /** Indicates whether the member is inherited by implicit conversion */ def isImplicitlyInherited: Boolean - /** Indicates whether there is another member with the same name in the template that will take precendence */ + /** Indicates whether there is another member with the same name in the template that will take precedence */ def isShadowedImplicit: Boolean /** Indicates whether there are other implicitly inherited members that have similar signatures (and thus they all diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala index 178af3d4ba..3432e5e150 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala @@ -478,7 +478,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { override lazy val comment = { def nonRootTemplate(sym: Symbol): Option[DocTemplateImpl] = if (sym eq RootPackage) None else findTemplateMaybe(sym) - /* Variable precendence order for implicitly added members: Take the variable definitions from ... + /* Variable precedence order for implicitly added members: Take the variable definitions from ... * 1. the target of the implicit conversion * 2. the definition template (owner) * 3. the current template @@ -994,7 +994,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { // pruning modules that shouldn't be documented // Why Symbol.isInitialized? Well, because we need to avoid exploring all the space available to scaladoc // from the classpath -- scaladoc is a hog, it will explore everything starting from the root package unless we - // somehow prune the tree. And isInitialized is a good heuristic for prunning -- if the package was not explored + // somehow prune the tree. And isInitialized is a good heuristic for pruning -- if the package was not explored // during typer and refchecks, it's not necessary for the current application and there's no need to explore it. (!sym.isModule || sym.moduleClass.isInitialized) && // documenting only public and protected members diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala index ea72fa6095..45745b5f55 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala @@ -112,7 +112,7 @@ trait ModelFactoryTypeSupport { def needsPrefix: Boolean = { if ((owner != bSym.owner || preSym.isRefinementClass) && (normalizeTemplate(owner) != inTpl.sym)) return true - // don't get tricked into prefixng method type params and existentials: + // don't get tricked into prefixing method type params and existentials: // I tried several tricks BUT adding the method for which I'm creating the type => that simply won't scale, // as ValueParams are independent of their parent member, and I really don't want to add this information to // all terms, as we're already over the allowed memory footprint |