fix dotty compile errors: ambiguous reference

giabao · giabao · commit 19585dd0b40e · 2020-04-07T23:47:05.000+07:00
diff --git a/scalatest/src/main/scala/org/scalatest/flatspec/AnyFlatSpecLike.scala b/scalatest/src/main/scala/org/scalatest/flatspec/AnyFlatSpecLike.scala
@@ -1562,17 +1562,17 @@ import resultOfStringPassedToVerb.verb
         new ResultOfStringPassedToVerb(verb, rest) {
 
           def is(testFun: => PendingStatement): Unit = {
-            registerTestToRun(verb.trim + " " + rest.trim, "is", List(), () => { testFun; succeed }, pos)
+            registerTestToRun(this.verb.trim + " " + this.rest.trim, "is", List(), () => { testFun; succeed }, pos)
           }
           // Note, won't have an is method that takes fixture => PendingStatement one, because don't want
           // to say is (fixture => pending), rather just say is (pending)
           def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
             val tagList = firstTestTag :: otherTestTags.toList
-            new ResultOfTaggedAsInvocation(verb, rest, tagList) {
+            new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {
               // "A Stack" should "bla bla" taggedAs(SlowTest) is (pending)
               //                                               ^
               def is(testFun: => PendingStatement): Unit = {
-                registerTestToRun(verb.trim + " " + rest.trim, "is", tags, () => { testFun; succeed }, pos)
+                registerTestToRun(this.verb.trim + " " + this.rest.trim, "is", this.tags, () => { testFun; succeed }, pos)
               }
             }
           }
diff --git a/scalatest/src/main/scala/org/scalatest/flatspec/AsyncFlatSpecLike.scala b/scalatest/src/main/scala/org/scalatest/flatspec/AsyncFlatSpecLike.scala
@@ -1564,17 +1564,17 @@ import resultOfStringPassedToVerb.verb
         new ResultOfStringPassedToVerb(verb, rest) {
 
           def is(testFun: => PendingStatement): Unit = {
-            registerPendingTestToRun(verb.trim + " " + rest.trim, "is", List(), () => testFun, pos)
+            registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, "is", List(), () => testFun, pos)
           }
             // Note, won't have an is method that takes fixture => PendingStatement one, because don't want
           // to say is (fixture => pending), rather just say is (pending)
           def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
             val tagList = firstTestTag :: otherTestTags.toList
-            new ResultOfTaggedAsInvocation(verb, rest, tagList) {
+            new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {
               // "A Stack" should "bla bla" taggedAs(SlowTest) is (pending)
               //                                               ^
               def is(testFun: => PendingStatement): Unit = {
-                registerPendingTestToRun(verb.trim + " " + rest.trim, "is", tags, () => testFun, pos)
+                registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, "is", this.tags, () => testFun, pos)
               }
             }
           }
diff --git a/scalatest/src/main/scala/org/scalatest/flatspec/FixtureAnyFlatSpecLike.scala b/scalatest/src/main/scala/org/scalatest/flatspec/FixtureAnyFlatSpecLike.scala
@@ -2011,15 +2011,15 @@ import resultOfStringPassedToVerb.verb
         registerFlatBranch(subject, Resources.shouldCannotAppearInsideAnIn, sourceFileName, "apply", stackDepth, 0, Some(pos))
         new ResultOfStringPassedToVerb(verb, rest) {
           def is(testFun: => PendingStatement): Unit = {
-            registerPendingTestToRun(verb.trim + " " + rest.trim, List(), "is", unusedFixtureParam => testFun, pos)
+            registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, List(), "is", unusedFixtureParam => testFun, pos)
           }
           def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
             val tagList = firstTestTag :: otherTestTags.toList
-            new ResultOfTaggedAsInvocation(verb, rest, tagList) {
+            new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {
               // "A Stack" must "test this" taggedAs(mytags.SlowAsMolasses) is (pending)
               //                                                            ^
               def is(testFun: => PendingStatement): Unit = {
-                registerPendingTestToRun(verb.trim + " " + rest.trim, tags, "is", new NoArgTestWrapper(() => testFun), pos)
+                registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, this.tags, "is", new NoArgTestWrapper(() => testFun), pos)
               }
             }
           }
diff --git a/scalatest/src/main/scala/org/scalatest/flatspec/FixtureAsyncFlatSpecLike.scala b/scalatest/src/main/scala/org/scalatest/flatspec/FixtureAsyncFlatSpecLike.scala
@@ -1988,15 +1988,15 @@ import resultOfStringPassedToVerb.verb
         registerFlatBranch(subject, Resources.shouldCannotAppearInsideAnIn, pos)
         new ResultOfStringPassedToVerb(verb, rest) {
           def is(testFun: => PendingStatement): Unit = {
-            registerPendingTestToRun(verb.trim + " " + rest.trim, List(), "is", unusedFixtureParam => testFun, pos)
+            registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, List(), "is", unusedFixtureParam => testFun, pos)
           }
           def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
             val tagList = firstTestTag :: otherTestTags.toList
-            new ResultOfTaggedAsInvocation(verb, rest, tagList) {
+            new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {
               // "A Stack" must "test this" taggedAs(mytags.SlowAsMolasses) is (pending)
               //                                                            ^
               def is(testFun: => PendingStatement): Unit = {
-                registerPendingTestToRun(verb.trim + " " + rest.trim, tags, "is", new NoArgTestWrapper(() => testFun), pos)
+                registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, this.tags, "is", new NoArgTestWrapper(() => testFun), pos)
               }
             }
           }

Original file line number	Diff line number	Diff line change
`@@ -1562,17 +1562,17 @@ import resultOfStringPassedToVerb.verb`
`1562`	`1562`	`new ResultOfStringPassedToVerb(verb, rest) {`
`1563`	`1563`
`1564`	`1564`	`def is(testFun: => PendingStatement): Unit = {`
`1565`		`- registerTestToRun(verb.trim + " " + rest.trim, "is", List(), () => { testFun; succeed }, pos)`
	`1565`	`+ registerTestToRun(this.verb.trim + " " + this.rest.trim, "is", List(), () => { testFun; succeed }, pos)`
`1566`	`1566`	`}`
`1567`	`1567`	`// Note, won't have an is method that takes fixture => PendingStatement one, because don't want`
`1568`	`1568`	`// to say is (fixture => pending), rather just say is (pending)`
`1569`	`1569`	`def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {`
`1570`	`1570`	`val tagList = firstTestTag :: otherTestTags.toList`
`1571`		`- new ResultOfTaggedAsInvocation(verb, rest, tagList) {`
	`1571`	`+ new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {`
`1572`	`1572`	`// "A Stack" should "bla bla" taggedAs(SlowTest) is (pending)`
`1573`	`1573`	`// ^`
`1574`	`1574`	`def is(testFun: => PendingStatement): Unit = {`
`1575`		`- registerTestToRun(verb.trim + " " + rest.trim, "is", tags, () => { testFun; succeed }, pos)`
	`1575`	`+ registerTestToRun(this.verb.trim + " " + this.rest.trim, "is", this.tags, () => { testFun; succeed }, pos)`
`1576`	`1576`	`}`
`1577`	`1577`	`}`
`1578`	`1578`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1564,17 +1564,17 @@ import resultOfStringPassedToVerb.verb`
`1564`	`1564`	`new ResultOfStringPassedToVerb(verb, rest) {`
`1565`	`1565`
`1566`	`1566`	`def is(testFun: => PendingStatement): Unit = {`
`1567`		`- registerPendingTestToRun(verb.trim + " " + rest.trim, "is", List(), () => testFun, pos)`
	`1567`	`+ registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, "is", List(), () => testFun, pos)`
`1568`	`1568`	`}`
`1569`	`1569`	`// Note, won't have an is method that takes fixture => PendingStatement one, because don't want`
`1570`	`1570`	`// to say is (fixture => pending), rather just say is (pending)`
`1571`	`1571`	`def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {`
`1572`	`1572`	`val tagList = firstTestTag :: otherTestTags.toList`
`1573`		`- new ResultOfTaggedAsInvocation(verb, rest, tagList) {`
	`1573`	`+ new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {`
`1574`	`1574`	`// "A Stack" should "bla bla" taggedAs(SlowTest) is (pending)`
`1575`	`1575`	`// ^`
`1576`	`1576`	`def is(testFun: => PendingStatement): Unit = {`
`1577`		`- registerPendingTestToRun(verb.trim + " " + rest.trim, "is", tags, () => testFun, pos)`
	`1577`	`+ registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, "is", this.tags, () => testFun, pos)`
`1578`	`1578`	`}`
`1579`	`1579`	`}`
`1580`	`1580`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2011,15 +2011,15 @@ import resultOfStringPassedToVerb.verb`
`2011`	`2011`	`registerFlatBranch(subject, Resources.shouldCannotAppearInsideAnIn, sourceFileName, "apply", stackDepth, 0, Some(pos))`
`2012`	`2012`	`new ResultOfStringPassedToVerb(verb, rest) {`
`2013`	`2013`	`def is(testFun: => PendingStatement): Unit = {`
`2014`		`- registerPendingTestToRun(verb.trim + " " + rest.trim, List(), "is", unusedFixtureParam => testFun, pos)`
	`2014`	`+ registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, List(), "is", unusedFixtureParam => testFun, pos)`
`2015`	`2015`	`}`
`2016`	`2016`	`def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {`
`2017`	`2017`	`val tagList = firstTestTag :: otherTestTags.toList`
`2018`		`- new ResultOfTaggedAsInvocation(verb, rest, tagList) {`
	`2018`	`+ new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {`
`2019`	`2019`	`// "A Stack" must "test this" taggedAs(mytags.SlowAsMolasses) is (pending)`
`2020`	`2020`	`// ^`
`2021`	`2021`	`def is(testFun: => PendingStatement): Unit = {`
`2022`		`- registerPendingTestToRun(verb.trim + " " + rest.trim, tags, "is", new NoArgTestWrapper(() => testFun), pos)`
	`2022`	`+ registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, this.tags, "is", new NoArgTestWrapper(() => testFun), pos)`
`2023`	`2023`	`}`
`2024`	`2024`	`}`
`2025`	`2025`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1988,15 +1988,15 @@ import resultOfStringPassedToVerb.verb`
`1988`	`1988`	`registerFlatBranch(subject, Resources.shouldCannotAppearInsideAnIn, pos)`
`1989`	`1989`	`new ResultOfStringPassedToVerb(verb, rest) {`
`1990`	`1990`	`def is(testFun: => PendingStatement): Unit = {`
`1991`		`- registerPendingTestToRun(verb.trim + " " + rest.trim, List(), "is", unusedFixtureParam => testFun, pos)`
	`1991`	`+ registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, List(), "is", unusedFixtureParam => testFun, pos)`
`1992`	`1992`	`}`
`1993`	`1993`	`def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {`
`1994`	`1994`	`val tagList = firstTestTag :: otherTestTags.toList`
`1995`		`- new ResultOfTaggedAsInvocation(verb, rest, tagList) {`
	`1995`	`+ new ResultOfTaggedAsInvocation(this.verb, this.rest, tagList) {`
`1996`	`1996`	`// "A Stack" must "test this" taggedAs(mytags.SlowAsMolasses) is (pending)`
`1997`	`1997`	`// ^`
`1998`	`1998`	`def is(testFun: => PendingStatement): Unit = {`
`1999`		`- registerPendingTestToRun(verb.trim + " " + rest.trim, tags, "is", new NoArgTestWrapper(() => testFun), pos)`
	`1999`	`+ registerPendingTestToRun(this.verb.trim + " " + this.rest.trim, this.tags, "is", new NoArgTestWrapper(() => testFun), pos)`
`2000`	`2000`	`}`
`2001`	`2001`	`}`
`2002`	`2002`	`}`