diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 7e97529fd22f..24708f45d4ad 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -169,7 +169,6 @@ trait Warnings { val AdaptedArgs = LintWarning("adapted-args", "An argument list was modified to match the receiver.") val NullaryUnit = LintWarning("nullary-unit", "`def f: Unit` looks like an accessor; add parens to look side-effecting.") val Inaccessible = LintWarning("inaccessible", "Warn about inaccessible types in method signatures.") - val NullaryOverride = LintWarning("nullary-override", "Non-nullary `def f()` overrides nullary `def f`.") val InferAny = LintWarning("infer-any", "A type argument was inferred as Any.") val MissingInterpolator = LintWarning("missing-interpolator", "A string literal appears to be missing an interpolator id.") val DocDetached = LintWarning("doc-detached", "When running scaladoc, warn if a doc comment is discarded.") @@ -200,7 +199,6 @@ trait Warnings { def warnAdaptedArgs = lint contains AdaptedArgs def warnNullaryUnit = lint contains NullaryUnit def warnInaccessible = lint contains Inaccessible - def warnNullaryOverride = lint contains NullaryOverride def warnInferAny = lint contains InferAny def warnMissingInterpolator = lint contains MissingInterpolator def warnDocDetached = lint contains DocDetached diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 4f3e08c48919..4eba7c85d8ae 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -1461,12 +1461,17 @@ trait Namers extends MethodSynthesis { // Note that matching MethodType of NullaryMethodType must be nilary not nelary. def overriddenNilary(sym: Symbol) = sym.info.isInstanceOf[MethodType] if (overridden != NoSymbol && vparamSymss.isEmpty && overridden.alternatives.exists(overriddenNilary)) { - if (settings.warnNullaryOverride) - context.unit.toCheck += {() => - def javaDetermined(sym: Symbol) = sym.isJavaDefined || isUniversalMember(sym) - if (!meth.overrides.exists(javaDetermined)) - context.warning(ddef.pos, "nullary method assumes an empty parameter list from the overridden definition", WarningCategory.LintNullaryOverride) - } + def exempt() = meth.overrides.exists(sym => sym.isJavaDefined || isUniversalMember(sym)) + val msg = "method without a parameter list overrides a method without params" + def error(): Unit = if (!exempt()) { + ErrorUtils.issueNormalTypeError(ddef, msg) + ddef.tpt.defineType(ErrorType) + } + def warn(): Unit = if (!exempt()) { + context.warning(ddef.pos, msg, WarningCategory.LintNullaryOverride) + meth.updateAttachment(NullaryOverrideAdapted) + } + context.unit.toCheck += (if (currentRun.isScala3) error _ else warn _) ListOfNil } else vparamSymss } diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 065ea1360dbb..d92501af6383 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -440,10 +440,16 @@ abstract class RefChecks extends Transform { // Don't bother users with deprecations caused by classes they inherit. // Only warn for the pair that has one leg in `clazz`. if (clazz == memberClass) checkOverrideDeprecated() - if (settings.warnNullaryOverride) { - def javaDetermined(sym: Symbol) = sym.isJavaDefined || isUniversalMember(sym) - if (other.paramss.isEmpty && !member.paramss.isEmpty && !javaDetermined(member) && !member.overrides.exists(javaDetermined)) - refchecksWarning(member.pos, "non-nullary method overrides nullary method", WarningCategory.LintNullaryOverride) + def javaDetermined(sym: Symbol) = sym.isJavaDefined || isUniversalMember(sym) + if (!member.hasAttachment[NullaryOverrideAdapted.type] + && other.paramss.isEmpty && !member.paramss.isEmpty + && !javaDetermined(member) && !member.overrides.exists(javaDetermined) + ) { + val msg = "method without params overrides method without a parameter list" + if (currentRun.isScala3) + overrideErrorWithMemberInfo(msg) + else + refchecksWarning(member.pos, msg, WarningCategory.LintNullaryOverride) } } } diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala index 20e8f8bb218c..5a0244bb29da 100644 --- a/src/reflect/scala/reflect/internal/StdAttachments.scala +++ b/src/reflect/scala/reflect/internal/StdAttachments.scala @@ -119,4 +119,6 @@ trait StdAttachments { class QualTypeSymAttachment(val sym: Symbol) case object ConstructorNeedsFence extends PlainAttachment + + case object NullaryOverrideAdapted extends PlainAttachment } diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala index 20b82f0a6e8a..af3b30df401e 100644 --- a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala +++ b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala @@ -64,6 +64,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse => this.TypeParamVarargsAttachment this.KnownDirectSubclassesCalled this.ConstructorNeedsFence + this.NullaryOverrideAdapted this.noPrint this.typeDebug // inaccessible: this.posAssigner diff --git a/test/files/jvm/named-args-in-order/Test.scala b/test/files/jvm/named-args-in-order/Test.scala index 36b9cbc1d127..64c5c9ee4ab1 100644 --- a/test/files/jvm/named-args-in-order/Test.scala +++ b/test/files/jvm/named-args-in-order/Test.scala @@ -1,7 +1,7 @@ import scala.tools.partest.BytecodeTest object Test extends BytecodeTest { - def show: Unit = { + def show(): Unit = { val classNode = loadClassNode("SameBytecode") def sameAsA(meth: String) = sameBytecode(getMethod(classNode, "a"), getMethod(classNode, meth)) diff --git a/test/files/neg/nilary-override.check b/test/files/neg/nilary-override.check deleted file mode 100644 index a35dc32b1790..000000000000 --- a/test/files/neg/nilary-override.check +++ /dev/null @@ -1,9 +0,0 @@ -nilary-override.scala:7: warning: nullary method assumes an empty parameter list from the overridden definition -class D extends C { override def x: Int = 4 } - ^ -nilary-override.scala:4: warning: non-nullary method overrides nullary method -class B extends A { override def x(): Int = 4 } - ^ -error: No warnings can be incurred under -Werror. -2 warnings -1 error diff --git a/test/files/neg/nilary-override.scala b/test/files/neg/nilary-override.scala deleted file mode 100644 index 9aa7fac18b85..000000000000 --- a/test/files/neg/nilary-override.scala +++ /dev/null @@ -1,13 +0,0 @@ -// scalac: -Werror -Xlint:nullary-override -Wunused:nowarn -// -class A { def x: Int = 3 } -class B extends A { override def x(): Int = 4 } - -class C { def x(): Int = 3 } -class D extends C { override def x: Int = 4 } - -class J { override def toString = "happy J" } - -import annotation._ -class E { def x(): Int = 3 } -class F extends E { @nowarn override def x: Int = 4 } diff --git a/test/files/neg/nullary-override-3a.check b/test/files/neg/nullary-override-3a.check new file mode 100644 index 000000000000..3cdfa3ff1775 --- /dev/null +++ b/test/files/neg/nullary-override-3a.check @@ -0,0 +1,13 @@ +nullary-override-3a.scala:4: error: method without params overrides method without a parameter list +def x: Int (defined in class A) +class B extends A { override def x(): Int = 4 } + ^ +nullary-override-3a.scala:16: error: method without params overrides method without a parameter list +def x: String (defined in trait T1) +class Mix12b extends T1 with T2 { override def x() = "12b" } + ^ +nullary-override-3a.scala:19: error: method without params overrides method without a parameter list +def x: String (defined in trait T1) +class Mix21b extends T2 with T1 { override def x() = "21b" } + ^ +3 errors diff --git a/test/files/neg/nullary-override-3a.scala b/test/files/neg/nullary-override-3a.scala new file mode 100644 index 000000000000..dbf30d034727 --- /dev/null +++ b/test/files/neg/nullary-override-3a.scala @@ -0,0 +1,40 @@ +// scalac: -Werror -Wunused:nowarn -Xsource:3 +// +class A { def x: Int = 3 } +class B extends A { override def x(): Int = 4 } + + +trait T1 { def x: String = "1" } +trait T2 { def x(): String = "2" } + +// without overrides you just get: error: class X inherits conflicting members: +// def x: String (defined in trait T1) and +// def x(): String (defined in trait T2) +// (note: this can be resolved by declaring an `override` in class X.) + +// Mix12a in nullary-override-3b +class Mix12b extends T1 with T2 { override def x() = "12b" } + +class Mix21a extends T2 with T1 { override def x = "21a" } +class Mix21b extends T2 with T1 { override def x() = "21b" } + +import java.util.concurrent.atomic.{ AtomicMarkableReference => AMR } +trait Ref1 { def getReference: String = "1" } +trait Ref2 { def getReference(): String = "2" } + +// without overrides you just get: error: class X inherits conflicting members: +// def getReference(): String (defined in class AtomicMarkableReference) and +// def getReference: String (defined in trait Ref1) +// (note: this can be resolved by declaring an `override` in class X.) + +class Mark1a extends AMR[String]("", false) with Ref1 { override def getReference = "1a" } +class Mark1b extends AMR[String]("", false) with Ref1 { override def getReference() = "1b" } + +class Mark2a extends AMR[String]("", false) with Ref2 { override def getReference = "2a" } +class Mark2b extends AMR[String]("", false) with Ref2 { override def getReference() = "2b" } + +class Mark12a extends AMR[String]("", false) with Ref1 with Ref2 { override def getReference = "12a" } +class Mark12b extends AMR[String]("", false) with Ref1 with Ref2 { override def getReference() = "12b" } + +class Mark21a extends AMR[String]("", false) with Ref2 with Ref1 { override def getReference = "21a" } +class Mark21c extends AMR[String]("", false) with Ref2 with Ref1 { override def getReference() = "21b" } diff --git a/test/files/neg/nullary-override-3b.check b/test/files/neg/nullary-override-3b.check new file mode 100644 index 000000000000..b89b215a1e32 --- /dev/null +++ b/test/files/neg/nullary-override-3b.check @@ -0,0 +1,7 @@ +nullary-override-3b.scala:6: error: method without a parameter list overrides a method without params +class Q extends P { override def x: Int = 4 } + ^ +nullary-override-3b.scala:11: error: method without a parameter list overrides a method without params +class Mix12a extends T1 with T2 { override def x = "12a" } + ^ +2 errors diff --git a/test/files/neg/nullary-override-3b.scala b/test/files/neg/nullary-override-3b.scala new file mode 100644 index 000000000000..265f9755b219 --- /dev/null +++ b/test/files/neg/nullary-override-3b.scala @@ -0,0 +1,12 @@ +// scalac: -Werror -Wunused:nowarn -Xsource:3 +// +// P has parens +class P { def x(): Int = 3 } +// Q is questionable +class Q extends P { override def x: Int = 4 } + +trait T1 { def x: String = "1" } +trait T2 { def x(): String = "2" } + +class Mix12a extends T1 with T2 { override def x = "12a" } +// the rest in nullary-override-3a diff --git a/test/files/neg/nullary-override.check b/test/files/neg/nullary-override.check index e183d4363dca..ef6775cd5e4c 100644 --- a/test/files/neg/nullary-override.check +++ b/test/files/neg/nullary-override.check @@ -1,9 +1,18 @@ -nullary-override.scala:15: warning: nullary method assumes an empty parameter list from the overridden definition +nullary-override.scala:15: warning: method without a parameter list overrides a method without params class Q extends P { override def x: Int = 4 } ^ -nullary-override.scala:4: warning: non-nullary method overrides nullary method +nullary-override.scala:36: warning: method without a parameter list overrides a method without params +class Mix12a extends T1 with T2 { override def x = "12a" } + ^ +nullary-override.scala:4: warning: method without params overrides method without a parameter list class B extends A { override def x(): Int = 4 } ^ +nullary-override.scala:37: warning: method without params overrides method without a parameter list +class Mix12b extends T1 with T2 { override def x() = "12b" } + ^ +nullary-override.scala:40: warning: method without params overrides method without a parameter list +class Mix21b extends T2 with T1 { override def x() = "21b" } + ^ error: No warnings can be incurred under -Werror. -2 warnings +5 warnings 1 error diff --git a/test/files/neg/nullary-override.scala b/test/files/neg/nullary-override.scala index e1122113d49b..18b713b94f64 100644 --- a/test/files/neg/nullary-override.scala +++ b/test/files/neg/nullary-override.scala @@ -1,4 +1,4 @@ -// scalac: -Werror -Xlint:nullary-override +// scalac: -Werror -Wunused:nowarn // class A { def x: Int = 3 } class B extends A { override def x(): Int = 4 } @@ -16,3 +16,46 @@ class Q extends P { override def x: Int = 4 } // Welcome to the Happy J class J { override def toString = "Happy J" } + +import annotation._ +class E { def x(): Int = 3 } +class F extends E { @nowarn override def x: Int = 4 } + +class G { def x: Int = 5 } +class H extends G { @nowarn override def x(): Int = 6 } + + +trait T1 { def x: String = "1" } +trait T2 { def x(): String = "2" } + +// without overrides you just get: error: class X inherits conflicting members: +// def x: String (defined in trait T1) and +// def x(): String (defined in trait T2) +// (note: this can be resolved by declaring an `override` in class X.) + +class Mix12a extends T1 with T2 { override def x = "12a" } +class Mix12b extends T1 with T2 { override def x() = "12b" } + +class Mix21a extends T2 with T1 { override def x = "21a" } +class Mix21b extends T2 with T1 { override def x() = "21b" } + +import java.util.concurrent.atomic.{ AtomicMarkableReference => AMR } +trait Ref1 { def getReference: String = "1" } +trait Ref2 { def getReference(): String = "2" } + +// without overrides you just get: error: class X inherits conflicting members: +// def getReference(): String (defined in class AtomicMarkableReference) and +// def getReference: String (defined in trait Ref1) +// (note: this can be resolved by declaring an `override` in class X.) + +class Mark1a extends AMR[String]("", false) with Ref1 { override def getReference = "1a" } +class Mark1b extends AMR[String]("", false) with Ref1 { override def getReference() = "1b" } + +class Mark2a extends AMR[String]("", false) with Ref2 { override def getReference = "2a" } +class Mark2b extends AMR[String]("", false) with Ref2 { override def getReference() = "2b" } + +class Mark12a extends AMR[String]("", false) with Ref1 with Ref2 { override def getReference = "12a" } +class Mark12b extends AMR[String]("", false) with Ref1 with Ref2 { override def getReference() = "12b" } + +class Mark21a extends AMR[String]("", false) with Ref2 with Ref1 { override def getReference = "21a" } +class Mark21c extends AMR[String]("", false) with Ref2 with Ref1 { override def getReference() = "21b" } diff --git a/test/files/neg/t5429.check b/test/files/neg/t5429.check index e793603c4387..eeba79ab10e3 100644 --- a/test/files/neg/t5429.check +++ b/test/files/neg/t5429.check @@ -1,3 +1,9 @@ +t5429.scala:68: warning: method without a parameter list overrides a method without params + def emptyArg = 10 // fail + ^ +t5429.scala:75: warning: method without a parameter list overrides a method without params + override def emptyArg = 10 // override + ^ t5429.scala:20: error: `override` modifier required to override concrete member: val value: Int (defined in class A) object value // fail @@ -145,4 +151,5 @@ Note: the super classes of class F0 contain the following, non final members nam def oneArg(x: String): Any override lazy val oneArg = 15 // fail ^ +2 warnings 34 errors diff --git a/test/files/neg/t8244b.scala b/test/files/neg/t8244b.scala index 2fb4f451a1dd..cd4cb0f7c1bc 100644 --- a/test/files/neg/t8244b.scala +++ b/test/files/neg/t8244b.scala @@ -5,7 +5,7 @@ class Raw_1[T]{ class X extends Raw_1[X] { - override def t = this + override def t() = this def exxx = 0 } diff --git a/test/files/neg/t8244c.scala b/test/files/neg/t8244c.scala index 2fb4f451a1dd..cd4cb0f7c1bc 100644 --- a/test/files/neg/t8244c.scala +++ b/test/files/neg/t8244c.scala @@ -5,7 +5,7 @@ class Raw_1[T]{ class X extends Raw_1[X] { - override def t = this + override def t() = this def exxx = 0 } diff --git a/test/files/pos/nullary-override-3.scala b/test/files/pos/nullary-override-3.scala new file mode 100644 index 000000000000..171ed5be8edc --- /dev/null +++ b/test/files/pos/nullary-override-3.scala @@ -0,0 +1,10 @@ +// scalac: -Werror -Wunused:nowarn -Xsource:3 +// +class C extends java.lang.CharSequence { + def charAt(x$1: Int): Char = ??? + def length: Int = ??? + def subSequence(x$1: Int, x$2: Int): CharSequence = ??? +} + +// Welcome to the Happy J +class J { override def toString = "Happy J" } diff --git a/test/files/run/Course-2002-10.scala b/test/files/run/Course-2002-10.scala index 64f31ac8e1f0..365523ea1e91 100644 --- a/test/files/run/Course-2002-10.scala +++ b/test/files/run/Course-2002-10.scala @@ -100,13 +100,13 @@ object M2 { class IntIterator(start: Int) extends Iterator[Int] { var current: Int = start; def hasNext = true; - def next = { current = current + 1; current - 1 }; + def next() = { current = current + 1; current - 1 }; } class PrimeIterator() extends Iterator[Int] { var current: Iterator[Int] = new IntIterator(2); def hasNext = true; - def next = { + def next() = { val p = current.next; current = current filter { x => !((x % p) == 0) }; p diff --git a/test/files/run/Course-2002-13.scala b/test/files/run/Course-2002-13.scala index 6ffc3c8501b6..10339fe23c7e 100644 --- a/test/files/run/Course-2002-13.scala +++ b/test/files/run/Course-2002-13.scala @@ -17,7 +17,7 @@ class Tokenizer(s: String, delimiters: String) extends Iterator[String] { i < s.length() } - def next: String = + def next(): String = if (hasNext) { val start = i; var ch = s.charAt(i); i = i + 1; diff --git a/test/files/run/bcodeInlinerMixed/Test_2.scala b/test/files/run/bcodeInlinerMixed/Test_2.scala index 58d03b3cc577..6825888193c1 100644 --- a/test/files/run/bcodeInlinerMixed/Test_2.scala +++ b/test/files/run/bcodeInlinerMixed/Test_2.scala @@ -12,7 +12,7 @@ class D { } object Test extends BytecodeTest { - def show: Unit = { + def show(): Unit = { val gIns = instructionsFromMethod(getMethod(loadClassNode("B"), "g")) val hIns = instructionsFromMethod(getMethod(loadClassNode("C"), "h")) for (i <- List(gIns, hIns)) { diff --git a/test/files/run/bugs.scala b/test/files/run/bugs.scala index d26816d6cc49..9583bfb41519 100644 --- a/test/files/run/bugs.scala +++ b/test/files/run/bugs.scala @@ -381,7 +381,7 @@ object Bug266Test { class Bug316MyIterator extends Iterator[Int] { def hasNext = false - def next = 42 + def next() = 42 } object Bug316Test { diff --git a/test/files/run/iterables.scala b/test/files/run/iterables.scala index 40710a737f7a..357867ced184 100644 --- a/test/files/run/iterables.scala +++ b/test/files/run/iterables.scala @@ -4,7 +4,7 @@ object Test extends App { private var i = 0 def iterator = new Iterator[Int] { def hasNext = i < n - def next = + def next() = if (hasNext) { val v = i; i += 1; v } else throw new IndexOutOfBoundsException("empty iterator") } diff --git a/test/files/run/lisp.scala b/test/files/run/lisp.scala index 17f1857f7ce7..7d0b7f9409ed 100644 --- a/test/files/run/lisp.scala +++ b/test/files/run/lisp.scala @@ -12,7 +12,7 @@ class LispTokenizer(s: String) extends Iterator[String] { while (i < s.length() && s.charAt(i) <= ' ') i += 1 i < s.length() } - def next: String = + def next(): String = if (hasNext) { val start = i if (isDelimiter(s charAt i)) i += 1 diff --git a/test/files/run/t4788-separate-compilation/Test_2.scala b/test/files/run/t4788-separate-compilation/Test_2.scala index 46821b2c53a0..3f2fefe6ac26 100644 --- a/test/files/run/t4788-separate-compilation/Test_2.scala +++ b/test/files/run/t4788-separate-compilation/Test_2.scala @@ -18,7 +18,7 @@ object Test extends BytecodeTest { .map(_.trim) } - def show: Unit = { + def show(): Unit = { // It seems like @java.lang.Deprecated shows up in both the // Deprecated attribute and RuntimeVisibleAnnotation attribute, // while @scala.deprecated only shows up in the Deprecated attribute. diff --git a/test/files/run/t4788/Test.scala b/test/files/run/t4788/Test.scala index 46821b2c53a0..3f2fefe6ac26 100644 --- a/test/files/run/t4788/Test.scala +++ b/test/files/run/t4788/Test.scala @@ -18,7 +18,7 @@ object Test extends BytecodeTest { .map(_.trim) } - def show: Unit = { + def show(): Unit = { // It seems like @java.lang.Deprecated shows up in both the // Deprecated attribute and RuntimeVisibleAnnotation attribute, // while @scala.deprecated only shows up in the Deprecated attribute. diff --git a/test/files/run/t7455/Test.scala b/test/files/run/t7455/Test.scala index f7d51bc06c0c..ad2577d5eb8c 100644 --- a/test/files/run/t7455/Test.scala +++ b/test/files/run/t7455/Test.scala @@ -12,7 +12,7 @@ import scala.tools.partest._ object Test extends DirectTest { override def code = "" - def show: Unit = { + def show(): Unit = { val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator") val compiler = newCompiler("-cp", classpath, "-d", testOutput.path) import compiler._, definitions._ diff --git a/test/files/run/t7852.scala b/test/files/run/t7852.scala index 9ec487ef5f8a..521ab4ec1a7c 100644 --- a/test/files/run/t7852.scala +++ b/test/files/run/t7852.scala @@ -9,7 +9,7 @@ import scala.jdk.CollectionConverters._ object Test extends BytecodeTest { val nullChecks = Set(asm.Opcodes.IFNONNULL, asm.Opcodes.IFNULL) - def show: Unit = { + def show(): Unit = { def test(methodName: String, expected: Int): Unit = { val classNode = loadClassNode("Lean") val methodNode = getMethod(classNode, methodName) diff --git a/test/files/run/t7974/Test.scala b/test/files/run/t7974/Test.scala index 647098d598cf..879313f45fc5 100644 --- a/test/files/run/t7974/Test.scala +++ b/test/files/run/t7974/Test.scala @@ -8,7 +8,7 @@ import scala.tools.nsc.util.stringFromWriter import scala.jdk.CollectionConverters._ object Test extends BytecodeTest { - def show: Unit = { + def show(): Unit = { val classNode = loadClassNode("Symbols", skipDebugInfo = true) classNode.methods.asScala.foreach(m => println(AsmUtils.textify(m))) } diff --git a/test/files/run/t8601-closure-elim.scala b/test/files/run/t8601-closure-elim.scala index fa523d516c01..406d822be76c 100644 --- a/test/files/run/t8601-closure-elim.scala +++ b/test/files/run/t8601-closure-elim.scala @@ -9,7 +9,7 @@ import scala.jdk.CollectionConverters._ object Test extends BytecodeTest { val nullChecks = Set(asm.Opcodes.NEW) - def show: Unit = { + def show(): Unit = { def test(methodName: String): Unit = { val classNode = loadClassNode("Foo") val methodNode = getMethod(classNode, "b") diff --git a/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala b/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala index 10a712cf3418..f3d9f8ef8d58 100644 --- a/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala +++ b/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala @@ -25,5 +25,5 @@ object Test extends DirectTest { } """ - def show = compile() + def show() = compile() } diff --git a/test/files/specialized/spec-matrix-new.scala b/test/files/specialized/spec-matrix-new.scala index f20058881b27..499c08188efd 100644 --- a/test/files/specialized/spec-matrix-new.scala +++ b/test/files/specialized/spec-matrix-new.scala @@ -20,7 +20,7 @@ class Matrix[@specialized A: ClassTag](val rows: Int, val cols: Int) { def rowsIterator: Iterator[Array[A]] = new Iterator[Array[A]] { var idx = 0; def hasNext = idx < rows - def next = { + def next() = { idx += 1 arr(idx - 1) } diff --git a/test/files/specialized/spec-matrix-old.scala b/test/files/specialized/spec-matrix-old.scala index ca77b3696ecf..363ae8fb53a2 100644 --- a/test/files/specialized/spec-matrix-old.scala +++ b/test/files/specialized/spec-matrix-old.scala @@ -22,7 +22,7 @@ class Matrix[@specialized A: ClassManifest](val rows: Int, val cols: Int) { def rowsIterator: Iterator[Array[A]] = new Iterator[Array[A]] { var idx = 0; def hasNext = idx < rows - def next = { + def next() = { idx += 1 arr(idx - 1) }