diff options
Diffstat (limited to 'src/compiler')
7 files changed, 28 insertions, 29 deletions
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index 8f2a17a2bf..eb0da7caef 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -439,7 +439,7 @@ abstract class BCodeIdiomatic extends SubComponent { else { emitTypeBased(JCodeMethodN.returnOpcodes, tk) } } - /* Emits one of tableswitch or lookoupswitch. + /* Emits one of tableswitch or lookupswitch. * * can-multi-thread */ diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 9c6889668d..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. * @@ -942,7 +942,7 @@ abstract class BTypes { */ def jvmWiseLUB(other: ClassBType): Either[NoClassBTypeInfo, ClassBType] = { def isNotNullOrNothing(c: ClassBType) = !c.isNullType && !c.isNothingType - assert(isNotNullOrNothing(this) && isNotNullOrNothing(other), s"jvmWiseLub for null or nothing: $this - $other") + assert(isNotNullOrNothing(this) && isNotNullOrNothing(other), s"jvmWiseLUB for null or nothing: $this - $other") tryEither { val res: ClassBType = (this.isInterface.orThrow, other.isInterface.orThrow) match { @@ -967,7 +967,7 @@ abstract class BTypes { firstCommonSuffix(this :: this.superClassesTransitive.orThrow, other :: other.superClassesTransitive.orThrow) } - assert(isNotNullOrNothing(res), s"jvmWiseLub computed: $res") + assert(isNotNullOrNothing(res), s"jvmWiseLUB computed: $res") Right(res) } } 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 542f58795a..a7ef5d5d2f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -1537,7 +1537,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/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 = { |