diff options
Diffstat (limited to 'test/files')
126 files changed, 278 insertions, 278 deletions
diff --git a/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala b/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala index 3cfbdf45e9..fc2907b6dc 100644 --- a/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala +++ b/test/files/neg/macro-blackbox-dynamic-materialization/Macros_1.scala @@ -18,7 +18,7 @@ object Macros { def impl[T: c.WeakTypeTag](c: Context) = { import c.universe._ val tpe = weakTypeOf[T] - if (tpe.members.exists(_.typeSignature =:= typeOf[Int])) + if (tpe.members.exists(_.info =:= typeOf[Int])) c.abort(c.enclosingPosition, "I don't like classes that contain integers") q"new Foo[$tpe]{ override def toString = ${tpe.toString} }" } diff --git a/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala b/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala index a6f7de23bb..8d776388ee 100644 --- a/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala +++ b/test/files/neg/macro-blackbox-fundep-materialization/Macros_1.scala @@ -15,12 +15,12 @@ object Iso { val sym = c.weakTypeOf[T].typeSymbol if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") - val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } def mkTpt() = { val core = Ident(TupleClass(fields.length) orElse UnitClass) if (fields.length == 0) core - else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature))) + else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) } def mkFrom() = { @@ -32,8 +32,8 @@ object Iso { List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))), emptyValDef, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) - c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List()))) + c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) } } diff --git a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala index 186c285871..5c04503260 100644 --- a/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala +++ b/test/files/neg/macro-divergence-controlled/Impls_Macros_1.scala @@ -9,8 +9,8 @@ object Complex { def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = { import c.universe._ val tpe = weakTypeOf[T] - for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { - val trecur = appliedType(typeOf[Complex[_]], List(f.typeSignature)) + for (f <- tpe.decls.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { + val trecur = appliedType(typeOf[Complex[_]], List(f.info)) if (c.openImplicits.tail.exists(ic => ic.pt =:= trecur)) c.abort(c.enclosingPosition, "diverging implicit expansion. reported by a macro!") val recur = c.inferImplicitValue(trecur, silent = true) if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur") diff --git a/test/files/neg/t8104/Macros_1.scala b/test/files/neg/t8104/Macros_1.scala index 2ad4bc5a99..e135bd807b 100644 --- a/test/files/neg/t8104/Macros_1.scala +++ b/test/files/neg/t8104/Macros_1.scala @@ -4,8 +4,8 @@ object Macros { def impl[T](c: Context)(implicit T: c.WeakTypeTag[T]) = { import c.universe._ import definitions._ - val fields = T.tpe.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } - val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.typeSignature)) + val fields = T.tpe.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.info)) q"new Generic[$T]{ type Repr = $Repr }" } }
\ No newline at end of file diff --git a/test/files/pos/t1957.scala b/test/files/pos/t1957.scala index f80cf730ed..711ce17deb 100644 --- a/test/files/pos/t1957.scala +++ b/test/files/pos/t1957.scala @@ -23,7 +23,7 @@ object Test { final type commonModuleType = Module {type settingsType = self.settingsType} type selfType >: self.type <: commonModuleType - // BTW: if we use the commented out type declarations, the code compiles successfully + // BTW: if we use the commented out type decls, the code compiles successfully // type gristType = Grist {type settingsType <: self.settingsType; type moduleType <: commonModuleType } val tools: List[Tool {type settingsType = self.settingsType}] diff --git a/test/files/run/all-overridden.scala b/test/files/run/all-overridden.scala index 1b798ef748..ff51fa19bf 100644 --- a/test/files/run/all-overridden.scala +++ b/test/files/run/all-overridden.scala @@ -6,6 +6,6 @@ object Test { def main(args: Array[String]): Unit = { // We should see g, but not f or $init$. - typeOf[Bar].declarations.toList.flatMap(_.allOverriddenSymbols) foreach println + typeOf[Bar].decls.toList.flatMap(_.overrides) foreach println } } diff --git a/test/files/run/existentials3-new.scala b/test/files/run/existentials3-new.scala index a422a7668f..5dfd7fb394 100644 --- a/test/files/run/existentials3-new.scala +++ b/test/files/run/existentials3-new.scala @@ -36,7 +36,7 @@ object Test { val g12 = { abstract class A extends Seq[U forSome { type U <: Int }] ; List[A]() } def printTpe(t: Type) = { - val s = if (isFreeType(t.typeSymbol)) t.typeSymbol.typeSignature.toString else t.typeSymbol.toString + val s = if (isFreeType(t.typeSymbol)) t.typeSymbol.info.toString else t.typeSymbol.toString println("%s, t=%s, s=%s".format(t, t.asInstanceOf[Product].productPrefix, s)) } def m[T: TypeTag](x: T) = printTpe(typeOf[T]) diff --git a/test/files/run/fail-non-value-types.scala b/test/files/run/fail-non-value-types.scala index a42fbbf481..d9a69e17c2 100644 --- a/test/files/run/fail-non-value-types.scala +++ b/test/files/run/fail-non-value-types.scala @@ -32,9 +32,9 @@ object Test { // [B <: <?>, That <: <?>](f: <?>)(implicit cbf: <?>)That // - println(map.typeSignature) - println(map.typeSignatureIn(cil)) - println(distinct.typeSignature) + println(map.info) + println(map.infoIn(cil)) + println(distinct.info) if (failed) sys.exit(1) } } diff --git a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala index 85d0f0bb7e..7ac8fccc3a 100644 --- a/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala +++ b/test/files/run/macro-divergence-spurious/Impls_Macros_1.scala @@ -10,8 +10,8 @@ object Complex { def impl[T: c.WeakTypeTag](c: Context): c.Expr[Complex[T]] = { import c.universe._ val tpe = weakTypeOf[T] - for (f <- tpe.declarations.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { - val trecur = appliedType(typeOf[Complex[_]], List(f.typeSignature)) + for (f <- tpe.decls.collect{case f: TermSymbol if f.isParamAccessor && !f.isMethod => f}) { + val trecur = appliedType(typeOf[Complex[_]], List(f.info)) val recur = c.inferImplicitValue(trecur, silent = true) if (recur == EmptyTree) c.abort(c.enclosingPosition, s"couldn't synthesize $trecur") } diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala index 6d79b13419..64aaa07bf2 100644 --- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala +++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-bad/Macros_Test_2.scala @@ -6,7 +6,7 @@ object Test extends App { import scala.reflect.runtime.universe._ import scala.reflect.runtime.{currentMirror => cm} import scala.tools.reflect.ToolBox - val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Typed(Apply(Ident(definitions.ListModule), List(Literal(Constant(1)), Literal(Constant(2)))), Ident(tpnme.WILDCARD_STAR)))) + val tree = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Typed(Apply(Ident(definitions.ListModule), List(Literal(Constant(1)), Literal(Constant(2)))), Ident(typeNames.WILDCARD_STAR)))) try cm.mkToolBox().eval(tree) catch { case ex: Throwable => println(ex.getMessage) } }
\ No newline at end of file diff --git a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala index 4bdc5bec00..eb067c25a5 100644 --- a/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala +++ b/test/files/run/macro-expand-varargs-explicit-over-nonvarargs-good/Impls_1.scala @@ -4,7 +4,7 @@ object Impls { def foo(c: Context)(xs: c.Expr[Int]*) = { import c.universe._ val stripped_xs = xs map (_.tree) toList match { - case List(Typed(stripped, Ident(wildstar))) if wildstar == tpnme.WILDCARD_STAR => List(stripped) + case List(Typed(stripped, Ident(wildstar))) if wildstar == typeNames.WILDCARD_STAR => List(stripped) case _ => ??? } val body = Apply(Select(Ident(definitions.PredefModule), TermName("println")), stripped_xs) diff --git a/test/files/run/macro-range/Expansion_Impossible_2.scala b/test/files/run/macro-range/Expansion_Impossible_2.scala index 514de6864a..242e83a61a 100644 --- a/test/files/run/macro-range/Expansion_Impossible_2.scala +++ b/test/files/run/macro-range/Expansion_Impossible_2.scala @@ -9,7 +9,7 @@ object Impls { import c.universe._ import Flag._ - val initName = nme.CONSTRUCTOR + val initName = termNames.CONSTRUCTOR // Either: // scala"{ var i = $low; val h = $hi; while (i < h) { $f(i); i = i + 1 } } // or: diff --git a/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala b/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala index ba12fb05e6..410ec1b527 100644 --- a/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala +++ b/test/files/run/macro-reflective-mamd-normal-mi/Macros_Test_2.scala @@ -11,7 +11,7 @@ object Test extends App { val macrobody = Select(Ident(TermName("Impls")), TermName("foo")) val macroparam = ValDef(NoMods, TermName("x"), TypeTree(definitions.IntClass.toType), EmptyTree) val macrodef = DefDef(Modifiers(MACRO), TermName("foo"), Nil, List(List(macroparam)), Ident(TypeName("Int")), macrobody) - val modulector = DefDef(NoMods, nme.CONSTRUCTOR, Nil, List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))) + val modulector = DefDef(NoMods, termNames.CONSTRUCTOR, Nil, List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))) val module = ModuleDef(NoMods, TermName("Macros"), Template(Nil, noSelfType, List(modulector, macrodef))) val macroapp = Apply(Select(Ident(TermName("Macros")), TermName("foo")), List(Literal(Constant(42)))) val tree = Block(List(macrodef, module), macroapp) diff --git a/test/files/run/macro-reify-type/Macros_1.scala b/test/files/run/macro-reify-type/Macros_1.scala index 6558492d07..c38cf8aa52 100644 --- a/test/files/run/macro-reify-type/Macros_1.scala +++ b/test/files/run/macro-reify-type/Macros_1.scala @@ -17,7 +17,7 @@ object StaticReflect { clazz member nameName match { case NoSymbol => c.error(c.enclosingPosition, s"No member called $nameName in $clazz.") ; reify(ru.NoType) case member => - val mtpe = member typeSignatureIn clazz + val mtpe = member infoIn clazz val mtag = c.reifyType(gen.mkRuntimeUniverseRef, Select(gen.mkRuntimeUniverseRef, TermName("rootMirror")), mtpe) val mtree = Select(mtag, TermName("tpe")) diff --git a/test/files/run/macro-reify-type/Test_2.scala b/test/files/run/macro-reify-type/Test_2.scala index 1f35973531..8ec60e9f61 100644 --- a/test/files/run/macro-reify-type/Test_2.scala +++ b/test/files/run/macro-reify-type/Test_2.scala @@ -5,16 +5,16 @@ object Test extends App { println(method[List[Int]]("map")) //val $u: scala.reflect.runtime.universe.type = scala.reflect.runtime.universe; //val $m: $u.Mirror = scala.reflect.runtime.universe.rootMirror; - //import $u._, $m._, Flag._ + //import $u._, $m._, Flag._, internal._ //val tpe = { - // val symdef$B2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("B"), NoPosition, DEFERRED | PARAM, false); - // val symdef$That2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("That"), NoPosition, DEFERRED | PARAM, false); - // val symdef$f2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("f"), NoPosition, PARAM, false); - // val symdef$bf2 = build.newNestedSymbol(build.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("bf"), NoPosition, IMPLICIT | PARAM, false); - // build.setTypeSignature(symdef$B2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor)); - // build.setTypeSignature(symdef$That2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor)); - // build.setTypeSignature(symdef$f2, TypeRef(ThisType(staticPackage("scala").asModule.moduleClass), staticClass("scala.Function1"), List(staticClass("scala.Int").asType.toTypeConstructor, TypeRef(NoPrefix, symdef$B2, List())))); - // build.setTypeSignature(symdef$bf2, TypeRef(ThisType(staticPackage("scala.collection.generic").asModule.moduleClass), staticClass("scala.collection.generic.CanBuildFrom"), List(TypeRef(ThisType(staticPackage("scala.collection.immutable").asModule.moduleClass), staticClass("scala.collection.immutable.List"), List(staticClass("scala.Int").asType.toTypeConstructor)), TypeRef(NoPrefix, symdef$B2, List()), TypeRef(NoPrefix, symdef$That2, List())))); + // val symdef$B2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("B"), NoPosition, DEFERRED | PARAM, false); + // val symdef$That2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TypeName("That"), NoPosition, DEFERRED | PARAM, false); + // val symdef$f2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("f"), NoPosition, PARAM, false); + // val symdef$bf2 = reificationSupport.newNestedSymbol(reificationSupport.selectTerm(staticClass("scala.collection.TraversableLike"), "map"), TermName("bf"), NoPosition, IMPLICIT | PARAM, false); + // reificationSupport.setInfo(symdef$B2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor)); + // reificationSupport.setInfo(symdef$That2, TypeBounds(staticClass("scala.Nothing").asType.toTypeConstructor, staticClass("scala.Any").asType.toTypeConstructor)); + // reificationSupport.setInfo(symdef$f2, TypeRef(ThisType(staticPackage("scala").asModule.moduleClass), staticClass("scala.Function1"), List(staticClass("scala.Int").asType.toTypeConstructor, TypeRef(NoPrefix, symdef$B2, List())))); + // reificationSupport.setInfo(symdef$bf2, TypeRef(ThisType(staticPackage("scala.collection.generic").asModule.moduleClass), staticClass("scala.collection.generic.CanBuildFrom"), List(TypeRef(ThisType(staticPackage("scala.collection.immutable").asModule.moduleClass), staticClass("scala.collection.immutable.List"), List(staticClass("scala.Int").asType.toTypeConstructor)), TypeRef(NoPrefix, symdef$B2, List()), TypeRef(NoPrefix, symdef$That2, List())))); // PolyType(List(symdef$B2, symdef$That2), MethodType(List(symdef$f2), MethodType(List(symdef$bf2), TypeRef(NoPrefix, symdef$That2, List())))) //} //println(tpe) diff --git a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala index 5fb7ca1679..0e549f4ab8 100644 --- a/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala +++ b/test/files/run/macro-typecheck-macrosdisabled/Impls_Macros_1.scala @@ -18,9 +18,9 @@ object Macros { val rupkg = c.mirror.staticModule("scala.reflect.runtime.package") val rusym = reificationSupport.selectTerm(rupkg, "universe") - val NullaryMethodType(rutpe) = rusym.typeSignature + val NullaryMethodType(rutpe) = rusym.info val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe) - reificationSupport.setTypeSignature(ru, rutpe) + reificationSupport.setInfo(ru, rutpe) val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2)))) val ttree2 = c.typecheck(tree2, withMacrosDisabled = true) diff --git a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala index 9fa35dda83..f99f5d2f80 100644 --- a/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala +++ b/test/files/run/macro-typecheck-macrosdisabled2/Impls_Macros_1.scala @@ -18,9 +18,9 @@ object Macros { val rupkg = c.mirror.staticModule("scala.reflect.runtime.package") val rusym = reificationSupport.selectTerm(rupkg, "universe") - val NullaryMethodType(rutpe) = rusym.typeSignature + val NullaryMethodType(rutpe) = rusym.info val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe) - reificationSupport.setTypeSignature(ru, rutpe) + reificationSupport.setInfo(ru, rutpe) val tree2 = Apply(Select(Ident(ru), TermName("reify")), List(Apply(Select(Ident(TermName("scala")), TermName("Array")), List(Literal(Constant(2)))))) val ttree2 = c.typecheck(tree2, withMacrosDisabled = true) diff --git a/test/files/run/macro-vampire-false-warning/Macros_1.scala b/test/files/run/macro-vampire-false-warning/Macros_1.scala index 51869d214f..63c34b3ab6 100644 --- a/test/files/run/macro-vampire-false-warning/Macros_1.scala +++ b/test/files/run/macro-vampire-false-warning/Macros_1.scala @@ -21,7 +21,7 @@ object Macros { val kvps = xs.map(_.tree).toList map { case Apply(TypeApply(Select(Apply(_, List(Literal(Constant(name: String)))), _), _), List(value)) => name -> value } // val fields = kvps map { case (k, v) => q"@body($v) def ${TermName(k)} = macro Macros.selFieldImpl" } val fields = kvps map { case (k, v) => DefDef( - Modifiers(MACRO, tpnme.EMPTY, List(Apply(Select(New(Ident(TypeName("body"))), nme.CONSTRUCTOR), List(v)))), + Modifiers(MACRO, typeNames.EMPTY, List(Apply(Select(New(Ident(TypeName("body"))), termNames.CONSTRUCTOR), List(v)))), TermName(k), Nil, Nil, Ident(TypeName("Any")), Select(Ident(TermName("Macros")), TermName("selFieldImpl"))) } // q"import scala.language.experimental.macros; class Workaround { ..$fields }; new Workaround{}" c.Expr[Any](Block( @@ -32,8 +32,8 @@ object Macros { Template( List(Select(Ident(TermName("scala")), TypeName("AnyRef"))), noSelfType, DefDef( - NoMods, nme.CONSTRUCTOR, Nil, List(Nil), TypeTree(), - Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))) + NoMods, termNames.CONSTRUCTOR, Nil, List(Nil), TypeTree(), + Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))) +: fields)), ClassDef( Modifiers(FINAL), TypeName("$anon"), Nil, @@ -41,9 +41,9 @@ object Macros { List(Ident(TypeName("Workaround"))), noSelfType, List( DefDef( - NoMods, nme.CONSTRUCTOR, Nil, List(Nil), TypeTree(), - Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))))))), - Apply(Select(New(Ident(TypeName("$anon"))), nme.CONSTRUCTOR), List()))) + NoMods, termNames.CONSTRUCTOR, Nil, List(Nil), TypeTree(), + Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))))))), + Apply(Select(New(Ident(TypeName("$anon"))), termNames.CONSTRUCTOR), List()))) } } diff --git a/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala b/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala index 60a8d011f1..a2e925bb3a 100644 --- a/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala +++ b/test/files/run/macro-whitebox-dynamic-materialization/Macros_1.scala @@ -18,7 +18,7 @@ object Macros { def impl[T: c.WeakTypeTag](c: Context) = { import c.universe._ val tpe = weakTypeOf[T] - if (tpe.members.exists(_.typeSignature =:= typeOf[Int])) + if (tpe.members.exists(_.info =:= typeOf[Int])) c.abort(c.enclosingPosition, "I don't like classes that contain integers") q"new Foo[$tpe]{ override def toString = ${tpe.toString} }" } diff --git a/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala b/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala index a8309e35b0..5e89e6b2f8 100644 --- a/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala +++ b/test/files/run/macro-whitebox-fundep-materialization/Macros_1.scala @@ -15,12 +15,12 @@ object Iso { val sym = c.weakTypeOf[T].typeSymbol if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") - val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + val fields = sym.info.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } def mkTpt() = { val core = Ident(TupleClass(fields.length) orElse UnitClass) if (fields.length == 0) core - else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature))) + else AppliedTypeTree(core, fields map (f => TypeTree(f.info))) } def mkFrom() = { @@ -32,8 +32,8 @@ object Iso { List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))), emptyValDef, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) - c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List()))) + c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), termNames.CONSTRUCTOR), List()))) } } diff --git a/test/files/run/no-pickle-skolems/Test_2.scala b/test/files/run/no-pickle-skolems/Test_2.scala index 3293dda66d..da55ad9df0 100644 --- a/test/files/run/no-pickle-skolems/Test_2.scala +++ b/test/files/run/no-pickle-skolems/Test_2.scala @@ -7,7 +7,7 @@ object Test { * named CC. */ def collectSymbols[T: TypeTag](inMethod: TermName, name: String): List[String] = { - val m = typeOf[T] member inMethod typeSignatureIn typeOf[T] + val m = typeOf[T] member inMethod infoIn typeOf[T] var buf: List[Symbol] = Nil var seen: Set[Symbol] = Set() def id(s: Symbol): Int = s.asInstanceOf[{ def id: Int }].id @@ -21,8 +21,8 @@ object Test { def loop(t: Type) { t match { case TypeRef(pre, sym, args) => loop(pre) ; check(sym) ; args foreach loop - case PolyType(tparams, restpe) => tparams foreach { tp => check(tp) ; check(tp.owner) ; loop(tp.typeSignature) } ; loop(restpe) - case MethodType(params, restpe) => params foreach { p => check(p) ; loop(p.typeSignature) } ; loop(restpe) + case PolyType(tparams, restpe) => tparams foreach { tp => check(tp) ; check(tp.owner) ; loop(tp.info) } ; loop(restpe) + case MethodType(params, restpe) => params foreach { p => check(p) ; loop(p.info) } ; loop(restpe) case _ => } } diff --git a/test/files/run/reflection-allmirrors-tostring.scala b/test/files/run/reflection-allmirrors-tostring.scala index 41bab5ac0e..f0614e9a98 100644 --- a/test/files/run/reflection-allmirrors-tostring.scala +++ b/test/files/run/reflection-allmirrors-tostring.scala @@ -1,4 +1,3 @@ - import scala.language.higherKinds import scala.reflect.runtime.universe._ @@ -40,6 +39,6 @@ object Test extends App { val c = cm.staticClass("C") val cc = typeOf[C].member(TypeName("C")).asClass - println(cm.reflectClass(c).reflectConstructor(c.typeSignature.member(nme.CONSTRUCTOR).asMethod)) - println(im.reflectClass(cc).reflectConstructor(cc.typeSignature.member(nme.CONSTRUCTOR).asMethod)) + println(cm.reflectClass(c).reflectConstructor(c.info.member(termNames.CONSTRUCTOR).asMethod)) + println(im.reflectClass(cc).reflectConstructor(cc.info.member(termNames.CONSTRUCTOR).asMethod)) } diff --git a/test/files/run/reflection-companiontype.scala b/test/files/run/reflection-companiontype.scala index 72c0444a70..7f2a37aaa9 100644 --- a/test/files/run/reflection-companiontype.scala +++ b/test/files/run/reflection-companiontype.scala @@ -12,11 +12,11 @@ object Test extends App { println(showRaw(typeOf[C].companionType.companionType, printKinds = true)) println(showRaw(typeOf[C.type].companionType, printKinds = true)) println("ClassInfoTypes") - println(showRaw(typeOf[C].typeSymbol.typeSignature.companionType, printKinds = true)) - println(showRaw(typeOf[C].typeSymbol.typeSignature.companionType.typeSymbol.typeSignature.companionType, printKinds = true)) - println(showRaw(typeOf[C.type].typeSymbol.typeSignature.companionType, printKinds = true)) + println(showRaw(typeOf[C].typeSymbol.info.companionType, printKinds = true)) + println(showRaw(typeOf[C].typeSymbol.info.companionType.typeSymbol.info.companionType, printKinds = true)) + println(showRaw(typeOf[C.type].typeSymbol.info.companionType, printKinds = true)) println("Unrelated") println(showRaw(typeOf[T].companionType, printKinds = true)) println(showRaw(cm.staticPackage("scala").moduleClass.asType.toType.companionType, printKinds = true)) - println(showRaw(cm.staticPackage("scala").typeSignature.companionType, printKinds = true)) + println(showRaw(cm.staticPackage("scala").info.companionType, printKinds = true)) }
\ No newline at end of file diff --git a/test/files/run/reflection-constructormirror-inner-badpath.scala b/test/files/run/reflection-constructormirror-inner-badpath.scala index 4bccff21fe..e7c06b32ae 100644 --- a/test/files/run/reflection-constructormirror-inner-badpath.scala +++ b/test/files/run/reflection-constructormirror-inner-badpath.scala @@ -12,8 +12,8 @@ class Foo{ val classTag = implicitly[ClassTag[R]] val cl = classTag.runtimeClass.getClassLoader val cm = runtimeMirror(cl) - val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod - val sig = constructor.typeSignature + val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod + val sig = constructor.info val sym = cm.classSymbol( classTag.runtimeClass ) try { val cls = cm.reflectClass( sym ) diff --git a/test/files/run/reflection-constructormirror-inner-good.scala b/test/files/run/reflection-constructormirror-inner-good.scala index 861332161f..c09da5b300 100644 --- a/test/files/run/reflection-constructormirror-inner-good.scala +++ b/test/files/run/reflection-constructormirror-inner-good.scala @@ -12,8 +12,8 @@ class Foo{ val classTag = implicitly[ClassTag[R]] val cl = classTag.runtimeClass.getClassLoader val cm = runtimeMirror(cl) - val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod - val sig = constructor.typeSignature + val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod + val sig = constructor.info val sym = cm.classSymbol( classTag.runtimeClass ) val cls = cm.reflect( this ).reflectClass( sym ) cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R] diff --git a/test/files/run/reflection-constructormirror-nested-badpath.scala b/test/files/run/reflection-constructormirror-nested-badpath.scala index 2983f185de..cf0de77e10 100644 --- a/test/files/run/reflection-constructormirror-nested-badpath.scala +++ b/test/files/run/reflection-constructormirror-nested-badpath.scala @@ -8,8 +8,8 @@ class Foo{ val classTag = implicitly[ClassTag[R]] val cl = classTag.runtimeClass.getClassLoader val cm = runtimeMirror(cl) - val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod - val sig = constructor.typeSignature + val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod + val sig = constructor.info val sym = cm.classSymbol( classTag.runtimeClass ) try { val cls = cm.reflect( this ).reflectClass( sym ) diff --git a/test/files/run/reflection-constructormirror-nested-good.scala b/test/files/run/reflection-constructormirror-nested-good.scala index 0b7c413975..363b720461 100644 --- a/test/files/run/reflection-constructormirror-nested-good.scala +++ b/test/files/run/reflection-constructormirror-nested-good.scala @@ -8,8 +8,8 @@ class Foo{ val classTag = implicitly[ClassTag[R]] val cl = classTag.runtimeClass.getClassLoader val cm = runtimeMirror(cl) - val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod - val sig = constructor.typeSignature + val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod + val sig = constructor.info val sym = cm.classSymbol( classTag.runtimeClass ) val cls = cm.reflectClass( sym ) cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R] diff --git a/test/files/run/reflection-constructormirror-toplevel-badpath.scala b/test/files/run/reflection-constructormirror-toplevel-badpath.scala index cf92929119..eda4aa0531 100644 --- a/test/files/run/reflection-constructormirror-toplevel-badpath.scala +++ b/test/files/run/reflection-constructormirror-toplevel-badpath.scala @@ -13,8 +13,8 @@ class Foo{ val classTag = implicitly[ClassTag[R]] val cl = classTag.runtimeClass.getClassLoader val cm = runtimeMirror(cl) - val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod - val sig = constructor.typeSignature + val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod + val sig = constructor.info val sym = cm.classSymbol( classTag.runtimeClass ) try { val cls = cm.reflect( this ).reflectClass( sym ) diff --git a/test/files/run/reflection-constructormirror-toplevel-good.scala b/test/files/run/reflection-constructormirror-toplevel-good.scala index b68134b2cb..9842d01695 100644 --- a/test/files/run/reflection-constructormirror-toplevel-good.scala +++ b/test/files/run/reflection-constructormirror-toplevel-good.scala @@ -13,8 +13,8 @@ class Foo{ val classTag = implicitly[ClassTag[R]] val cl = classTag.runtimeClass.getClassLoader val cm = runtimeMirror(cl) - val constructor = expectedType.tpe.member( nme.CONSTRUCTOR ).asMethod - val sig = constructor.typeSignature + val constructor = expectedType.tpe.member( termNames.CONSTRUCTOR ).asMethod + val sig = constructor.info val sym = cm.classSymbol( classTag.runtimeClass ) val cls = cm.reflectClass( sym ) cls.reflectConstructor( constructor )( 5,"test" ).asInstanceOf[R] diff --git a/test/files/run/reflection-enclosed-basic.scala b/test/files/run/reflection-enclosed-basic.scala index 7b9e0c20dc..e001207e82 100644 --- a/test/files/run/reflection-enclosed-basic.scala +++ b/test/files/run/reflection-enclosed-basic.scala @@ -12,7 +12,7 @@ private object B6 extends B2 { override def toString = "B6"; override def foo = object Test extends App { def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } @@ -20,7 +20,7 @@ object Test extends App { def testNestedClass(name: String) = { val sym = cm.staticClass(name) println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor) val instance = ctorMirror() println(instance) diff --git a/test/files/run/reflection-enclosed-inner-basic.scala b/test/files/run/reflection-enclosed-inner-basic.scala index c1cf9bc336..fd81a8d115 100644 --- a/test/files/run/reflection-enclosed-inner-basic.scala +++ b/test/files/run/reflection-enclosed-inner-basic.scala @@ -14,19 +14,19 @@ class B { object Test extends App { val b = cm.classSymbol(classTag[B].runtimeClass) println(b) - println(b.typeSignature.declarations.toList) + println(b.info.decls.toList) def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } def testInnerClass(name: String) = { - val sym = b.typeSignature.declaration(TypeName(name)).asClass + val sym = b.info.decl(TypeName(name)).asClass println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val ctorMirror = cm.reflect(new B).reflectClass(sym).reflectConstructor(ctor) val instance = ctorMirror() println(instance) @@ -37,7 +37,7 @@ object Test extends App { testInnerClass("B2") def testInnerModule(name: String) = { - val sym = b.typeSignature.declaration(TermName(name)).asModule + val sym = b.info.decl(TermName(name)).asModule println(sym) val moduleMirror = cm.reflect(new B).reflectModule(sym) val instance = moduleMirror.instance diff --git a/test/files/run/reflection-enclosed-inner-inner-basic.scala b/test/files/run/reflection-enclosed-inner-inner-basic.scala index 8a73fac522..45dfb8a61f 100644 --- a/test/files/run/reflection-enclosed-inner-inner-basic.scala +++ b/test/files/run/reflection-enclosed-inner-inner-basic.scala @@ -16,19 +16,19 @@ class B { object Test extends App { val b = cm.classSymbol(classTag[B#BB].runtimeClass) println(b) - println(b.typeSignature.declarations.toList) + println(b.info.decls.toList) def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } def testInnerClass(name: String) = { - val sym = b.typeSignature.declaration(TypeName(name)).asClass + val sym = b.info.decl(TypeName(name)).asClass println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val outer1 = new B val outer2 = new outer1.BB val ctorMirror = cm.reflect(outer2).reflectClass(sym).reflectConstructor(ctor) @@ -41,7 +41,7 @@ object Test extends App { testInnerClass("B2") def testInnerModule(name: String) = { - val sym = b.typeSignature.declaration(TermName(name)).asModule + val sym = b.info.decl(TermName(name)).asModule println(sym) val outer1 = new B val outer2 = new outer1.BB diff --git a/test/files/run/reflection-enclosed-inner-nested-basic.scala b/test/files/run/reflection-enclosed-inner-nested-basic.scala index 6c2fc6df7a..1973f47397 100644 --- a/test/files/run/reflection-enclosed-inner-nested-basic.scala +++ b/test/files/run/reflection-enclosed-inner-nested-basic.scala @@ -17,19 +17,19 @@ object Test extends App { val outer1 = new B() val b = cm.moduleSymbol(classTag[outer1.BB.type].runtimeClass) println(b) - println(b.typeSignature.declarations.toList) + println(b.info.decls.toList) def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } def testNestedClass(name: String) = { - val sym = b.typeSignature.declaration(TypeName(name)).asClass + val sym = b.info.decl(TypeName(name)).asClass println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val ctorMirror = cm.reflect(outer1.BB).reflectClass(sym).reflectConstructor(ctor) val instance = ctorMirror() println(instance) @@ -40,7 +40,7 @@ object Test extends App { testNestedClass("B2") def testNestedModule(name: String) = { - val sym = b.typeSignature.declaration(TermName(name)).asModule + val sym = b.info.decl(TermName(name)).asModule println(sym) val moduleMirror = cm.reflect(outer1.BB).reflectModule(sym) val instance = moduleMirror.instance diff --git a/test/files/run/reflection-enclosed-nested-basic.scala b/test/files/run/reflection-enclosed-nested-basic.scala index 180ac4ebee..4ff333d10f 100644 --- a/test/files/run/reflection-enclosed-nested-basic.scala +++ b/test/files/run/reflection-enclosed-nested-basic.scala @@ -14,19 +14,19 @@ object B { object Test extends App { val b = cm.moduleSymbol(classTag[B.type].runtimeClass) println(b) - println(b.typeSignature.declarations.toList) + println(b.info.decls.toList) def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } def testNestedClass(name: String) = { - val sym = b.typeSignature.declaration(TypeName(name)).asClass + val sym = b.info.decl(TypeName(name)).asClass println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor) val instance = ctorMirror() println(instance) @@ -37,7 +37,7 @@ object Test extends App { testNestedClass("B2") def testNestedModule(name: String) = { - val sym = b.typeSignature.declaration(TermName(name)).asModule + val sym = b.info.decl(TermName(name)).asModule println(sym) val moduleMirror = cm.reflectModule(sym) val instance = moduleMirror.instance diff --git a/test/files/run/reflection-enclosed-nested-inner-basic.scala b/test/files/run/reflection-enclosed-nested-inner-basic.scala index 2558b8035a..d45894c8c2 100644 --- a/test/files/run/reflection-enclosed-nested-inner-basic.scala +++ b/test/files/run/reflection-enclosed-nested-inner-basic.scala @@ -16,19 +16,19 @@ object B { object Test extends App { val b = cm.classSymbol(classTag[B.BB].runtimeClass) println(b) - println(b.typeSignature.declarations.toList) + println(b.info.decls.toList) def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } def testInnerClass(name: String) = { - val sym = b.typeSignature.declaration(TypeName(name)).asClass + val sym = b.info.decl(TypeName(name)).asClass println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val ctorMirror = cm.reflect(new B.BB).reflectClass(sym).reflectConstructor(ctor) val instance = ctorMirror() println(instance) @@ -39,7 +39,7 @@ object Test extends App { testInnerClass("B2") def testInnerModule(name: String) = { - val sym = b.typeSignature.declaration(TermName(name)).asModule + val sym = b.info.decl(TermName(name)).asModule println(sym) val moduleMirror = cm.reflect(new B.BB).reflectModule(sym) val instance = moduleMirror.instance diff --git a/test/files/run/reflection-enclosed-nested-nested-basic.scala b/test/files/run/reflection-enclosed-nested-nested-basic.scala index b4711c9a8c..8a630ea1fb 100644 --- a/test/files/run/reflection-enclosed-nested-nested-basic.scala +++ b/test/files/run/reflection-enclosed-nested-nested-basic.scala @@ -16,19 +16,19 @@ object B { object Test extends App { val b = cm.moduleSymbol(classTag[B.BB.type].runtimeClass) println(b) - println(b.typeSignature.declarations.toList) + println(b.info.decls.toList) def testMethodInvocation(instance: Any) = { val instanceMirror = cm.reflect(instance) - val method = instanceMirror.symbol.typeSignature.declaration(TermName("foo")).asMethod + val method = instanceMirror.symbol.info.decl(TermName("foo")).asMethod val methodMirror = instanceMirror.reflectMethod(method) println(methodMirror()) } def testNestedClass(name: String) = { - val sym = b.typeSignature.declaration(TypeName(name)).asClass + val sym = b.info.decl(TypeName(name)).asClass println(sym) - val ctor = sym.typeSignature.declaration(nme.CONSTRUCTOR).asMethod + val ctor = sym.info.decl(termNames.CONSTRUCTOR).asMethod val ctorMirror = cm.reflectClass(sym).reflectConstructor(ctor) val instance = ctorMirror() println(instance) @@ -39,7 +39,7 @@ object Test extends App { testNestedClass("B2") def testNestedModule(name: String) = { - val sym = b.typeSignature.declaration(TermName(name)).asModule + val sym = b.info.decl(TermName(name)).asModule println(sym) val moduleMirror = cm.reflectModule(sym) val instance = moduleMirror.instance diff --git a/test/files/run/reflection-equality.check b/test/files/run/reflection-equality.check index 3af3ad774d..682326bc18 100644 --- a/test/files/run/reflection-equality.check +++ b/test/files/run/reflection-equality.check @@ -20,17 +20,17 @@ im: reflect.runtime.universe.InstanceMirror scala> val cs: ClassSymbol = im.symbol cs: reflect.runtime.universe.ClassSymbol = class X -scala> val ts: Type = cs.typeSignature +scala> val ts: Type = cs.info ts: reflect.runtime.universe.Type = scala.AnyRef { def <init>(): X def methodIntIntInt(x: scala.Int,y: scala.Int): scala.Int } -scala> val ms: MethodSymbol = ts.declaration(TermName("methodIntIntInt")).asMethod +scala> val ms: MethodSymbol = ts.decl(TermName("methodIntIntInt")).asMethod ms: reflect.runtime.universe.MethodSymbol = method methodIntIntInt -scala> val MethodType( _, t1 ) = ms.typeSignature +scala> val MethodType( _, t1 ) = ms.info t1: reflect.runtime.universe.Type = scala.Int scala> val t2 = typeOf[scala.Int] diff --git a/test/files/run/reflection-equality.scala b/test/files/run/reflection-equality.scala index 40f116bb53..0416bc7726 100644 --- a/test/files/run/reflection-equality.scala +++ b/test/files/run/reflection-equality.scala @@ -10,9 +10,9 @@ object Test extends ReplTest { |import scala.reflect.runtime.{ currentMirror => cm } |def im: InstanceMirror = cm.reflect(new X) |val cs: ClassSymbol = im.symbol - |val ts: Type = cs.typeSignature - |val ms: MethodSymbol = ts.declaration(TermName("methodIntIntInt")).asMethod - |val MethodType( _, t1 ) = ms.typeSignature + |val ts: Type = cs.info + |val ms: MethodSymbol = ts.decl(TermName("methodIntIntInt")).asMethod + |val MethodType( _, t1 ) = ms.info |val t2 = typeOf[scala.Int] |t1 == t2 |t1 =:= t2 diff --git a/test/files/run/reflection-fieldmirror-accessorsareokay.scala b/test/files/run/reflection-fieldmirror-accessorsareokay.scala index 3926ab7835..0e75dcf7e6 100644 --- a/test/files/run/reflection-fieldmirror-accessorsareokay.scala +++ b/test/files/run/reflection-fieldmirror-accessorsareokay.scala @@ -24,6 +24,6 @@ object Test extends App { } } - test(cs.typeSignature.declaration(TermName("x")).asTerm) - test(cs.typeSignature.declaration(TermName("x_$eq")).asTerm) + test(cs.info.decl(TermName("x")).asTerm) + test(cs.info.decl(TermName("x_$eq")).asTerm) } diff --git a/test/files/run/reflection-fieldmirror-ctorparam.scala b/test/files/run/reflection-fieldmirror-ctorparam.scala index 608adad27b..b5b6b21027 100644 --- a/test/files/run/reflection-fieldmirror-ctorparam.scala +++ b/test/files/run/reflection-fieldmirror-ctorparam.scala @@ -10,7 +10,7 @@ object Test extends App { val im: InstanceMirror = cm.reflect(a) val cs = im.symbol - val f = cs.typeSignature.declaration(TermName("x")).asTerm + val f = cs.info.decl(TermName("x")).asTerm try { val fm: FieldMirror = im.reflectField(f) println(fm.get) diff --git a/test/files/run/reflection-fieldmirror-getsetval.scala b/test/files/run/reflection-fieldmirror-getsetval.scala index 6a88dc3118..4fe0d2e4f3 100644 --- a/test/files/run/reflection-fieldmirror-getsetval.scala +++ b/test/files/run/reflection-fieldmirror-getsetval.scala @@ -10,7 +10,7 @@ object Test extends App { val im: InstanceMirror = cm.reflect(a) val cs = im.symbol - val f = cs.typeSignature.declaration(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm + val f = cs.info.decl(TermName("x" + termNames.LOCAL_SUFFIX_STRING)).asTerm val fm: FieldMirror = im.reflectField(f) println(fm.get) fm.set(2) diff --git a/test/files/run/reflection-fieldmirror-getsetvar.scala b/test/files/run/reflection-fieldmirror-getsetvar.scala index 52c13a73bb..c64b0c46c0 100644 --- a/test/files/run/reflection-fieldmirror-getsetvar.scala +++ b/test/files/run/reflection-fieldmirror-getsetvar.scala @@ -10,7 +10,7 @@ object Test extends App { val im: InstanceMirror = cm.reflect(a) val cs = im.symbol - val f = cs.typeSignature.declaration(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm + val f = cs.info.decl(TermName("x" + termNames.LOCAL_SUFFIX_STRING)).asTerm val fm: FieldMirror = im.reflectField(f) println(fm.get) fm.set(2) diff --git a/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala b/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala index e070cdcfa3..ddc6c42e78 100644 --- a/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala +++ b/test/files/run/reflection-fieldmirror-nmelocalsuffixstring.scala @@ -10,7 +10,7 @@ object Test extends App { val im: InstanceMirror = cm.reflect(a) val cs = im.symbol - val f = cs.typeSignature.declaration(TermName("x" + nme.LOCAL_SUFFIX_STRING)).asTerm + val f = cs.info.decl(TermName("x" + termNames.LOCAL_SUFFIX_STRING)).asTerm val fm: FieldMirror = im.reflectField(f) println(fm.symbol.isVar) } diff --git a/test/files/run/reflection-fieldmirror-privatethis.scala b/test/files/run/reflection-fieldmirror-privatethis.scala index 89948772b1..1ece46576d 100644 --- a/test/files/run/reflection-fieldmirror-privatethis.scala +++ b/test/files/run/reflection-fieldmirror-privatethis.scala @@ -10,7 +10,7 @@ object Test extends App { val im: InstanceMirror = cm.reflect(a) val cs = im.symbol - val f = cs.typeSignature.declaration(TermName("x")).asTerm + val f = cs.info.decl(TermName("x")).asTerm val fm: FieldMirror = im.reflectField(f) println(fm.symbol.isVar) println(fm.get) diff --git a/test/files/run/reflection-idtc.scala b/test/files/run/reflection-idtc.scala index bbe90f6826..f9eae612f0 100644 --- a/test/files/run/reflection-idtc.scala +++ b/test/files/run/reflection-idtc.scala @@ -5,7 +5,7 @@ import scala.tools.reflect.ToolBox object Test extends App { val tb = cm.mkToolBox() val idsym = tb.typecheck(q"type Id[X] = X").symbol.asType - val idTC1 = idsym.typeSignature + val idTC1 = idsym.info println(idTC1) println(appliedType(idTC1, List(typeOf[Int]))) println("===") diff --git a/test/files/run/reflection-implClass.scala b/test/files/run/reflection-implClass.scala index e11b8a2a16..4242530dd1 100644 --- a/test/files/run/reflection-implClass.scala +++ b/test/files/run/reflection-implClass.scala @@ -10,19 +10,19 @@ object Test extends App with Outer { import scala.reflect.runtime.universe._ import scala.reflect.runtime.{currentMirror => cm} - assert(cm.classSymbol(classTag[Foo].runtimeClass).typeSignature.declaration(TermName("bar")).typeSignature == - cm.classSymbol(classTag[Bar].runtimeClass).typeSignature.declaration(TermName("foo")).typeSignature) + assert(cm.classSymbol(classTag[Foo].runtimeClass).info.decl(TermName("bar")).info == + cm.classSymbol(classTag[Bar].runtimeClass).info.decl(TermName("foo")).info) val s1 = implClass(classTag[Foo].runtimeClass) assert(s1 != NoSymbol) - assert(s1.typeSignature != NoType) - assert(s1.companion.typeSignature != NoType) - assert(s1.companion.typeSignature.declaration(TermName("bar")) != NoSymbol) + assert(s1.info != NoType) + assert(s1.companion.info != NoType) + assert(s1.companion.info.decl(TermName("bar")) != NoSymbol) val s2 = implClass(classTag[Bar].runtimeClass) assert(s2 != NoSymbol) - assert(s2.typeSignature != NoType) - assert(s2.companion.typeSignature != NoType) - assert(s2.companion.typeSignature.declaration(TermName("foo")) != NoSymbol) + assert(s2.info != NoType) + assert(s2.companion.info != NoType) + assert(s2.companion.info.decl(TermName("foo")) != NoSymbol) def implClass(clazz: Class[_]) = { val implClass = Class.forName(clazz.getName + "$class") cm.classSymbol(implClass) diff --git a/test/files/run/reflection-implicit.scala b/test/files/run/reflection-implicit.scala index f2b3ba960c..a6e939322a 100644 --- a/test/files/run/reflection-implicit.scala +++ b/test/files/run/reflection-implicit.scala @@ -9,9 +9,9 @@ class C { } object Test extends App { - val decls = typeOf[C].typeSymbol.typeSignature.declarations.sorted.toList.filter(sym => !sym.isTerm || (sym.isMethod && !sym.asMethod.isConstructor)) + val decls = typeOf[C].typeSymbol.info.decls.sorted.toList.filter(sym => !sym.isTerm || (sym.isMethod && !sym.asMethod.isConstructor)) println(decls map (_.isImplicit)) - val param = decls.find(_.name.toString == "d").get.asMethod.paramss.last.head - param.typeSignature + val param = decls.find(_.name.toString == "d").get.asMethod.paramLists.last.head + param.info println(param.isImplicit) } diff --git a/test/files/run/reflection-java-annotations/Test_2.scala b/test/files/run/reflection-java-annotations/Test_2.scala index 5c9e9afdb7..dec5b45ca7 100644 --- a/test/files/run/reflection-java-annotations/Test_2.scala +++ b/test/files/run/reflection-java-annotations/Test_2.scala @@ -1,7 +1,7 @@ object Test extends App { import scala.reflect.runtime.universe._ val sym = typeOf[JavaAnnottee_1].typeSymbol - sym.typeSignature + sym.info sym.annotations foreach (_.javaArgs) println(sym.annotations) println("=======") diff --git a/test/files/run/reflection-java-crtp/Main_2.scala b/test/files/run/reflection-java-crtp/Main_2.scala index fb5668f323..b9347869e4 100644 --- a/test/files/run/reflection-java-crtp/Main_2.scala +++ b/test/files/run/reflection-java-crtp/Main_2.scala @@ -3,6 +3,6 @@ object Test extends App { val enum = typeOf[JavaSimpleEnumeration_1].baseClasses(1).asClass // make sure that the E's in Enum<E extends Enum<E>> are represented by the same symbol val e1 = enum.typeParams(0).asType - val TypeBounds(_, TypeRef(_, _, List(TypeRef(_, e2: TypeSymbol, _)))) = e1.typeSignature + val TypeBounds(_, TypeRef(_, _, List(TypeRef(_, e2: TypeSymbol, _)))) = e1.info println(e1, e2, e1 eq e2) }
\ No newline at end of file diff --git a/test/files/run/reflection-magicsymbols-invoke.scala b/test/files/run/reflection-magicsymbols-invoke.scala index ff3992709f..793f78bff4 100644 --- a/test/files/run/reflection-magicsymbols-invoke.scala +++ b/test/files/run/reflection-magicsymbols-invoke.scala @@ -9,7 +9,7 @@ package scala { } object Test extends App { - def key(sym: Symbol) = sym + ": " + sym.typeSignature + def key(sym: Symbol) = sym + ": " + sym.info def test(tpe: Type, receiver: Any, method: String, args: Any*) { def wrap[T](op: => T) = try { @@ -24,11 +24,11 @@ object Test extends App { } print(s"testing ${tpe.typeSymbol.name}.$method: ") wrap({ - if (method == nme.CONSTRUCTOR.toString) { - val ctor = tpe.declaration(nme.CONSTRUCTOR).asMethod + if (method == termNames.CONSTRUCTOR.toString) { + val ctor = tpe.decl(termNames.CONSTRUCTOR).asMethod cm.reflectClass(ctor.owner.asClass).reflectConstructor(ctor)(args: _*) } else { - val meth = tpe.declaration(TermName(method).encodedName.toTermName).asMethod + val meth = tpe.decl(TermName(method).encodedName.toTermName).asMethod cm.reflect(receiver).reflectMethod(meth)(args: _*) } }) @@ -53,8 +53,8 @@ object Test extends App { println("============\nAnyVal") println("it's important to print the list of AnyVal's members") println("if some of them change (possibly, adding and/or removing magic symbols), we must update this test") - typeOf[AnyVal].declarations.toList.sortBy(key).foreach(sym => println(key(sym))) - test(typeOf[AnyVal], null, nme.CONSTRUCTOR.toString) + typeOf[AnyVal].decls.toList.sortBy(key).foreach(sym => println(key(sym))) + test(typeOf[AnyVal], null, termNames.CONSTRUCTOR.toString) test(typeOf[AnyVal], 2, "getClass") println("============\nAnyRef") @@ -84,17 +84,17 @@ object Test extends App { println("============\nArray") println("it's important to print the list of Array's members") println("if some of them change (possibly, adding and/or removing magic symbols), we must update this test") - ArrayClass.typeSignature.members.toList.sortBy(key).foreach(sym => println(key(sym))) - test(ArrayClass.typeSignature, Array(1, 2), "length") - test(ArrayClass.typeSignature, Array(1, 2), "apply", 0) - test(ArrayClass.typeSignature, Array(1, 2), "update", 0, 0) - test(ArrayClass.typeSignature, Array(1, 2), "clone") + ArrayClass.info.members.toList.sortBy(key).foreach(sym => println(key(sym))) + test(ArrayClass.info, Array(1, 2), "length") + test(ArrayClass.info, Array(1, 2), "apply", 0) + test(ArrayClass.info, Array(1, 2), "update", 0, 0) + test(ArrayClass.info, Array(1, 2), "clone") println("============\nOther") test(typeOf[String], "2", "+", 3) println("============\nCTM") - test(PredefModule.moduleClass.typeSignature, Predef, "classOf") - test(PredefModule.moduleClass.typeSignature, Predef, "classOf", typeOf[String]) + test(PredefModule.moduleClass.info, Predef, "classOf") + test(PredefModule.moduleClass.info, Predef, "classOf", typeOf[String]) test(typeOf[scala.reflect.api.Universe], scala.reflect.runtime.universe, "reify", "2") }
\ No newline at end of file diff --git a/test/files/run/reflection-magicsymbols-repl.check b/test/files/run/reflection-magicsymbols-repl.check index 46c21dfa00..a1bee76652 100644 --- a/test/files/run/reflection-magicsymbols-repl.check +++ b/test/files/run/reflection-magicsymbols-repl.check @@ -17,9 +17,9 @@ scala> class A { defined class A scala> def test(n: Int): Unit = { - val sig = typeOf[A] member TermName("foo" + n) typeSignature + val sig = typeOf[A] member TermName("foo" + n) info val x = sig.asInstanceOf[MethodType].params.head - println(x.typeSignature) + println(x.info) } warning: there were 1 feature warning(s); re-run with -feature for details test: (n: Int)Unit diff --git a/test/files/run/reflection-magicsymbols-repl.scala b/test/files/run/reflection-magicsymbols-repl.scala index 6a432c2664..c006e85b3a 100644 --- a/test/files/run/reflection-magicsymbols-repl.scala +++ b/test/files/run/reflection-magicsymbols-repl.scala @@ -14,9 +14,9 @@ object Test extends ReplTest { | def foo8(x: Singleton) = ??? |} |def test(n: Int): Unit = { - | val sig = typeOf[A] member TermName("foo" + n) typeSignature + | val sig = typeOf[A] member TermName("foo" + n) info | val x = sig.asInstanceOf[MethodType].params.head - | println(x.typeSignature) + | println(x.info) |} |for (i <- 1 to 8) test(i) |""".stripMargin diff --git a/test/files/run/reflection-magicsymbols-vanilla.scala b/test/files/run/reflection-magicsymbols-vanilla.scala index 2bde3d8874..328caf945d 100644 --- a/test/files/run/reflection-magicsymbols-vanilla.scala +++ b/test/files/run/reflection-magicsymbols-vanilla.scala @@ -14,9 +14,9 @@ class A { object Test extends App { import scala.reflect.runtime.universe._ def test(n: Int): Unit = { - val sig = typeOf[A] member TermName("foo" + n) typeSignature + val sig = typeOf[A] member TermName("foo" + n) info val x = sig.asInstanceOf[MethodType].params.head - println(x.typeSignature) + println(x.info) } for (i <- 1 to 8) test(i) } diff --git a/test/files/run/reflection-methodsymbol-params.scala b/test/files/run/reflection-methodsymbol-params.scala index baad8d6b9b..bc1289a625 100644 --- a/test/files/run/reflection-methodsymbol-params.scala +++ b/test/files/run/reflection-methodsymbol-params.scala @@ -13,12 +13,12 @@ class C { } object Test extends App { - println(typeOf[C].member(TermName("x1")).asMethod.paramss) - println(typeOf[C].member(TermName("x2")).asMethod.paramss) - println(typeOf[C].member(TermName("x3")).asMethod.paramss) - println(typeOf[C].member(TermName("x4")).asMethod.paramss) - println(typeOf[C].member(TermName("y1")).asMethod.paramss) - println(typeOf[C].member(TermName("y2")).asMethod.paramss) - println(typeOf[C].member(TermName("y3")).asMethod.paramss) - println(typeOf[C].member(TermName("y4")).asMethod.paramss) + println(typeOf[C].member(TermName("x1")).asMethod.paramLists) + println(typeOf[C].member(TermName("x2")).asMethod.paramLists) + println(typeOf[C].member(TermName("x3")).asMethod.paramLists) + println(typeOf[C].member(TermName("x4")).asMethod.paramLists) + println(typeOf[C].member(TermName("y1")).asMethod.paramLists) + println(typeOf[C].member(TermName("y2")).asMethod.paramLists) + println(typeOf[C].member(TermName("y3")).asMethod.paramLists) + println(typeOf[C].member(TermName("y4")).asMethod.paramLists) }
\ No newline at end of file diff --git a/test/files/run/reflection-repl-classes.check b/test/files/run/reflection-repl-classes.check index 874fed2d7c..03a6aef2b5 100644 --- a/test/files/run/reflection-repl-classes.check +++ b/test/files/run/reflection-repl-classes.check @@ -17,7 +17,7 @@ scala> object defs { val cm = reflect.runtime.currentMirror val u = cm.universe val im = cm.reflect(new B) - val method = im.symbol.typeSignature.member(u.TermName("foo")).asMethod + val method = im.symbol.info.member(u.TermName("foo")).asMethod val mm = im.reflectMethod(method) } defined object defs diff --git a/test/files/run/reflection-repl-classes.scala b/test/files/run/reflection-repl-classes.scala index 4bfb980498..048e6b8ce0 100644 --- a/test/files/run/reflection-repl-classes.scala +++ b/test/files/run/reflection-repl-classes.scala @@ -12,7 +12,7 @@ object Test extends ReplTest { | val cm = reflect.runtime.currentMirror | val u = cm.universe | val im = cm.reflect(new B) - | val method = im.symbol.typeSignature.member(u.TermName("foo")).asMethod + | val method = im.symbol.info.member(u.TermName("foo")).asMethod | val mm = im.reflectMethod(method) |} |import defs._ diff --git a/test/files/run/reflection-sanitychecks.scala b/test/files/run/reflection-sanitychecks.scala index 6d3daff1f7..3f4873bbee 100644 --- a/test/files/run/reflection-sanitychecks.scala +++ b/test/files/run/reflection-sanitychecks.scala @@ -38,7 +38,7 @@ object Test extends App { println("method #2: " + failsafe(im.reflectMethod(tpe.member(TermName("baz")).asMethod)())) println("constructor #1: " + failsafe(cm.reflectClass(im.symbol).reflectConstructor(tpe.member(TermName("bar")).asMethod)())) println("constructor #2: " + failsafe(cm.reflectClass(im.symbol).reflectConstructor(tpe.member(TermName("<init>")).asMethod)())) - println("class: " + failsafe(im.reflectClass(tpe.member(TypeName("C")).asClass).reflectConstructor(typeOf[C].member(TypeName("C")).asClass.typeSignature.member(nme.CONSTRUCTOR).asMethod)())) + println("class: " + failsafe(im.reflectClass(tpe.member(TypeName("C")).asClass).reflectConstructor(typeOf[C].member(TypeName("C")).asClass.info.member(termNames.CONSTRUCTOR).asMethod)())) println("object: " + failsafe(im.reflectModule(tpe.member(TermName("O")).asModule).instance)) println() } diff --git a/test/files/run/reflection-sorted-decls.scala b/test/files/run/reflection-sorted-decls.scala index 5616e10b3b..8dcb0f3ec6 100644 --- a/test/files/run/reflection-sorted-decls.scala +++ b/test/files/run/reflection-sorted-decls.scala @@ -2,7 +2,7 @@ object Test { def main(args: Array[String]) { class Foo(val a: Int, val b: Int, val c: Int) import scala.reflect.runtime.{currentMirror => cm} - val decls = cm.classSymbol(classOf[Foo]).typeSignature.declarations + val decls = cm.classSymbol(classOf[Foo]).info.decls decls.sorted.toList.filter(!_.isMethod) foreach System.out.println } } diff --git a/test/files/run/reflection-sorted-members.scala b/test/files/run/reflection-sorted-members.scala index a8379234c0..fa028c99c6 100644 --- a/test/files/run/reflection-sorted-members.scala +++ b/test/files/run/reflection-sorted-members.scala @@ -5,7 +5,7 @@ object Test { class Bar(val x: Int) class Foo(val a: Int, val b: Int, val c: Int) extends Bar(a + b + c) with T1 with T2 import scala.reflect.runtime.{currentMirror => cm} - val members = cm.classSymbol(classOf[Foo]).typeSignature.members + val members = cm.classSymbol(classOf[Foo]).info.members members.sorted.toList.filter(!_.isMethod) foreach System.out.println } } diff --git a/test/files/run/reflection-sync-potpourri.scala b/test/files/run/reflection-sync-potpourri.scala index 0c96974df7..f65131f18a 100644 --- a/test/files/run/reflection-sync-potpourri.scala +++ b/test/files/run/reflection-sync-potpourri.scala @@ -16,7 +16,7 @@ object Test extends App { () => typeOf[scala.io.Codec]) val perms = types.permutations.toList def force(lazytpe: () => Type): String = { - lazytpe().typeSymbol.typeSignature + lazytpe().typeSymbol.info lazytpe().toString } val diceRolls = List.fill(n)(rng.nextInt(perms.length)) diff --git a/test/files/run/reflection-tags.scala b/test/files/run/reflection-tags.scala index 39bb8cf4e5..21ff2c0efb 100644 --- a/test/files/run/reflection-tags.scala +++ b/test/files/run/reflection-tags.scala @@ -9,10 +9,10 @@ object Test extends App { typeMembers = typeMembers.filter(_.name != TypeName("Compat")) // internal val tags = typeOf[scala.reflect.api.Universe].members.filter(sym => sym.isImplicit).toList - typeMembers.foreach(_.typeSignature) - tags.foreach(_.typeSignature) + typeMembers.foreach(_.info) + tags.foreach(_.info) - val outliers = typeMembers.filter(tm => !tags.exists(tag => tag.typeSignature match { + val outliers = typeMembers.filter(tm => !tags.exists(tag => tag.info match { case NullaryMethodType(TypeRef(_, sym, targ :: Nil)) => sym == typeOf[ClassTag[_]].typeSymbol && targ.typeSymbol == tm case _ => false })) diff --git a/test/files/run/reflection-valueclasses-magic.scala b/test/files/run/reflection-valueclasses-magic.scala index 33d4634397..366b5fe270 100644 --- a/test/files/run/reflection-valueclasses-magic.scala +++ b/test/files/run/reflection-valueclasses-magic.scala @@ -13,9 +13,9 @@ object Test extends App { def key(sym: Symbol) = { sym match { // initialize parameter symbols - case meth: MethodSymbol => meth.paramss.flatten.map(_.typeSignature) + case meth: MethodSymbol => meth.paramLists.flatten.map(_.info) } - sym + ": " + sym.typeSignature + sym + ": " + sym.info } def convert(value: Any, tpe: Type) = { @@ -44,11 +44,11 @@ object Test extends App { val realex = scala.ExceptionUtils.unwrapThrowable(ex) println(realex.getClass + ": " + realex.getMessage) } - val meth = tpe.declaration(TermName(method).encodedName.toTermName) + val meth = tpe.decl(TermName(method).encodedName.toTermName) val testees = if (meth.isMethod) List(meth.asMethod) else meth.asTerm.alternatives.map(_.asMethod) testees foreach (testee => { - val convertedArgs = args.zipWithIndex.map { case (arg, i) => convert(arg, testee.paramss.flatten.apply(i).typeSignature) } - print(s"testing ${tpe.typeSymbol.name}.$method(${testee.paramss.flatten.map(_.typeSignature).mkString(','.toString)}) with receiver = $receiver and args = ${convertedArgs.map(arg => arg + ' '.toString + arg.getClass).toList}: ") + val convertedArgs = args.zipWithIndex.map { case (arg, i) => convert(arg, testee.paramLists.flatten.apply(i).info) } + print(s"testing ${tpe.typeSymbol.name}.$method(${testee.paramLists.flatten.map(_.info).mkString(','.toString)}) with receiver = $receiver and args = ${convertedArgs.map(arg => arg + ' '.toString + arg.getClass).toList}: ") wrap(cm.reflect(receiver).reflectMethod(testee)(convertedArgs: _*)) }) } diff --git a/test/files/run/showdecl/Macros_1.scala b/test/files/run/showdecl/Macros_1.scala index d0493fb97f..c68dd275de 100644 --- a/test/files/run/showdecl/Macros_1.scala +++ b/test/files/run/showdecl/Macros_1.scala @@ -8,20 +8,20 @@ object Macros { import c.universe._ def test(sym: Symbol): Unit = { - println(s"uninitialized ${sym.name}: ${showDeclaration(sym)}") - sym.typeSignature - println(s"initialized ${sym.name}: ${showDeclaration(sym)}") + println(s"uninitialized ${sym.name}: ${showDecl(sym)}") + sym.info + println(s"initialized ${sym.name}: ${showDecl(sym)}") } println("compile-time") test(c.mirror.staticClass("D")) - test(c.mirror.staticClass("D").typeSignature.member(TermName("x"))) - test(c.mirror.staticClass("D").typeSignature.member(TermName("y"))) - test(c.mirror.staticClass("D").typeSignature.member(TermName("z"))) - test(c.mirror.staticClass("D").typeSignature.member(TermName("t"))) - test(c.mirror.staticClass("D").typeSignature.member(TypeName("W"))) - test(c.mirror.staticClass("D").typeSignature.member(TypeName("C"))) - test(c.mirror.staticClass("D").typeSignature.member(TermName("O"))) + test(c.mirror.staticClass("D").info.member(TermName("x"))) + test(c.mirror.staticClass("D").info.member(TermName("y"))) + test(c.mirror.staticClass("D").info.member(TermName("z"))) + test(c.mirror.staticClass("D").info.member(TermName("t"))) + test(c.mirror.staticClass("D").info.member(TypeName("W"))) + test(c.mirror.staticClass("D").info.member(TypeName("C"))) + test(c.mirror.staticClass("D").info.member(TermName("O"))) q"..${messages.map(msg => q"println($msg)")}" } diff --git a/test/files/run/showdecl/Test_2.scala b/test/files/run/showdecl/Test_2.scala index 65ab2f147c..6eb64baf34 100644 --- a/test/files/run/showdecl/Test_2.scala +++ b/test/files/run/showdecl/Test_2.scala @@ -3,9 +3,9 @@ import scala.reflect.runtime.{currentMirror => cm} object Test extends App { def test(sym: Symbol): Unit = { - println(s"autoinitialized ${sym.name}: ${showDeclaration(sym)}") - sym.typeSignature - println(s"autoinitialized ${sym.name}: ${showDeclaration(sym)}") + println(s"autoinitialized ${sym.name}: ${showDecl(sym)}") + sym.info + println(s"autoinitialized ${sym.name}: ${showDecl(sym)}") } Macros.foo diff --git a/test/files/run/showraw_tree.check b/test/files/run/showraw_tree.check index eb74bd8b2b..d8cb1fde02 100644 --- a/test/files/run/showraw_tree.check +++ b/test/files/run/showraw_tree.check @@ -1,2 +1,2 @@ -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List()) -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List()) diff --git a/test/files/run/showraw_tree_ids.check b/test/files/run/showraw_tree_ids.check index 7e0149a3c1..d7a7aa5959 100644 --- a/test/files/run/showraw_tree_ids.check +++ b/test/files/run/showraw_tree_ids.check @@ -1,2 +1,2 @@ -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), nme.CONSTRUCTOR), List()) -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), nme.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), termNames.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#<id>), List(Select(Ident(scala.Predef#<id>), TypeName("String")), Select(Ident(scala.Predef#<id>), TypeName("String"))))), termNames.CONSTRUCTOR), List()) diff --git a/test/files/run/showraw_tree_kinds.check b/test/files/run/showraw_tree_kinds.check index 577f447ae4..85939b02f0 100644 --- a/test/files/run/showraw_tree_kinds.check +++ b/test/files/run/showraw_tree_kinds.check @@ -1,2 +1,2 @@ -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), nme.CONSTRUCTOR), List()) -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), nme.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), termNames.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap#CLS), List(Select(Ident(scala.Predef#MOD), TypeName("String")), Select(Ident(scala.Predef#MOD), TypeName("String"))))), termNames.CONSTRUCTOR), List()) diff --git a/test/files/run/showraw_tree_types_ids.check b/test/files/run/showraw_tree_types_ids.check index 6a73d77436..75347463cb 100644 --- a/test/files/run/showraw_tree_types_ids.check +++ b/test/files/run/showraw_tree_types_ids.check @@ -1,10 +1,10 @@ -Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List()) +Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), termNames.CONSTRUCTOR#<id>), List()) [1] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()))) [2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())))) [3] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List()) [4] TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()) [5] SingleType(ThisType(scala#<id>), scala.Predef#<id>) -Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), nme.CONSTRUCTOR#<id>), List()) +Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), termNames.CONSTRUCTOR#<id>), List()) [4] TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()) [5] SingleType(ThisType(scala#<id>), scala.Predef#<id>) [6] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()))) diff --git a/test/files/run/showraw_tree_types_typed.check b/test/files/run/showraw_tree_types_typed.check index cf63ecb586..de691e369e 100644 --- a/test/files/run/showraw_tree_types_typed.check +++ b/test/files/run/showraw_tree_types_typed.check @@ -1,10 +1,10 @@ -Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), nme.CONSTRUCTOR), List()) +Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), termNames.CONSTRUCTOR), List()) [1] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()))) [2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())))) [3] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List()) [4] TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()) [5] SingleType(ThisType(scala), scala.Predef) -Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), nme.CONSTRUCTOR), List()) +Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), termNames.CONSTRUCTOR), List()) [4] TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()) [5] SingleType(ThisType(scala), scala.Predef) [6] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()))) diff --git a/test/files/run/showraw_tree_types_untyped.check b/test/files/run/showraw_tree_types_untyped.check index eb74bd8b2b..d8cb1fde02 100644 --- a/test/files/run/showraw_tree_types_untyped.check +++ b/test/files/run/showraw_tree_types_untyped.check @@ -1,2 +1,2 @@ -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List()) -Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), nme.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.immutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List()) +Apply(Select(New(AppliedTypeTree(Ident(scala.collection.mutable.HashMap), List(Select(Ident(scala.Predef), TypeName("String")), Select(Ident(scala.Predef), TypeName("String"))))), termNames.CONSTRUCTOR), List()) diff --git a/test/files/run/showraw_tree_ultimate.check b/test/files/run/showraw_tree_ultimate.check index ea64d5a7d2..81efcc05ab 100644 --- a/test/files/run/showraw_tree_ultimate.check +++ b/test/files/run/showraw_tree_ultimate.check @@ -1,10 +1,10 @@ -Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#PCTOR), List()) +Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.immutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), termNames.CONSTRUCTOR#<id>#PCTOR), List()) [1] TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))) [2] MethodType(List(), TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))) [3] TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List()) [4] TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()) [5] SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD) -Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), nme.CONSTRUCTOR#<id>#CTOR), List()) +Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), termNames.CONSTRUCTOR#<id>#CTOR), List()) [4] TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()) [5] SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD) [6] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))) diff --git a/test/files/run/t1195-new.scala b/test/files/run/t1195-new.scala index 4f068c7d42..fcb80082a2 100644 --- a/test/files/run/t1195-new.scala +++ b/test/files/run/t1195-new.scala @@ -11,7 +11,7 @@ object Test { val g1 = g() val h1 = h() - def m[T: WeakTypeTag](x: T) = println(weakTypeOf[T] + ", underlying = " + weakTypeOf[T].typeSymbol.typeSignature) + def m[T: WeakTypeTag](x: T) = println(weakTypeOf[T] + ", underlying = " + weakTypeOf[T].typeSymbol.info) def main(args: Array[String]): Unit = { m(f) diff --git a/test/files/run/t3425b/Base_1.scala b/test/files/run/t3425b/Base_1.scala index 5a660a89b2..bdbc124d29 100644 --- a/test/files/run/t3425b/Base_1.scala +++ b/test/files/run/t3425b/Base_1.scala @@ -80,7 +80,7 @@ object Gen { | sshow("Reflective Calls", fcalls collect { case (true, n) => n }) | // For a good time try printing this - have to fix bugs in | // reflection before that's going to be a good idea - | // println(typeOf[Test.type].typeSymbol.asClass.typeSignature) + | // println(typeOf[Test.type].typeSymbol.asClass.info) | } |} """.stripMargin.trim diff --git a/test/files/run/t3425b/Generated_2.scala b/test/files/run/t3425b/Generated_2.scala index f1699636f6..d08f17e8b2 100644 --- a/test/files/run/t3425b/Generated_2.scala +++ b/test/files/run/t3425b/Generated_2.scala @@ -881,6 +881,6 @@ object Test { sshow("Reflective Calls", fcalls collect { case (true, n) => n }) // For a good time try printing this - have to fix bugs in // reflection before that's going to be a good idea - // println(typeOf[Test.type].typeSymbol.asClass.typeSignature) + // println(typeOf[Test.type].typeSymbol.asClass.info) } } diff --git a/test/files/run/t5256a.scala b/test/files/run/t5256a.scala index 84ef97b0d2..c8cea53028 100644 --- a/test/files/run/t5256a.scala +++ b/test/files/run/t5256a.scala @@ -7,5 +7,5 @@ object Test extends App { val c = cm.classSymbol(classOf[A]) println(c) println(c.fullName) - println(c.typeSignature) + println(c.info) }
\ No newline at end of file diff --git a/test/files/run/t5256b.scala b/test/files/run/t5256b.scala index 0ffab8a668..5cd172e032 100644 --- a/test/files/run/t5256b.scala +++ b/test/files/run/t5256b.scala @@ -6,5 +6,5 @@ object Test extends App { val c = cm.classSymbol(classOf[A]) println(c) println(c.fullName) - println(c.typeSignature) + println(c.info) }
\ No newline at end of file diff --git a/test/files/run/t5256c.scala b/test/files/run/t5256c.scala index d56215f6eb..66ddd3df5c 100644 --- a/test/files/run/t5256c.scala +++ b/test/files/run/t5256c.scala @@ -7,6 +7,6 @@ object Test extends App { val c = cm.classSymbol(classOf[A]) println(c) println(c.fullName) - println(c.typeSignature) + println(c.info) } }
\ No newline at end of file diff --git a/test/files/run/t5256d.check b/test/files/run/t5256d.check index 5705acf20a..d42d234386 100644 --- a/test/files/run/t5256d.check +++ b/test/files/run/t5256d.check @@ -19,7 +19,7 @@ class A scala> println(c.fullName) $line8.$read.$iw.$iw.$iw.$iw.A -scala> println(c.typeSignature) +scala> println(c.info) scala.AnyRef { def <init>(): A def foo: scala.Nothing diff --git a/test/files/run/t5256d.scala b/test/files/run/t5256d.scala index 24ac1eb316..5aa26071c0 100644 --- a/test/files/run/t5256d.scala +++ b/test/files/run/t5256d.scala @@ -8,6 +8,6 @@ class A { def foo = ??? } val c = cm.classSymbol(classOf[A]) println(c) println(c.fullName) -println(c.typeSignature) +println(c.info) """ }
\ No newline at end of file diff --git a/test/files/run/t5256e.scala b/test/files/run/t5256e.scala index f83546f2c0..2f57ea68b9 100644 --- a/test/files/run/t5256e.scala +++ b/test/files/run/t5256e.scala @@ -6,5 +6,5 @@ object Test extends App { val c = cm.classSymbol(classOf[C#A]) println(c) println(c.fullName) - println(c.typeSignature) + println(c.info) }
\ No newline at end of file diff --git a/test/files/run/t5256f.scala b/test/files/run/t5256f.scala index 80c7ad8018..1de2592416 100644 --- a/test/files/run/t5256f.scala +++ b/test/files/run/t5256f.scala @@ -7,7 +7,7 @@ object Test extends App { val c1 = cm.classSymbol(classOf[A1]) println(c1) println(c1.fullName) - println(c1.typeSignature) + println(c1.info) new Test } @@ -18,5 +18,5 @@ class Test { val c2 = cm.classSymbol(classOf[A2]) println(c2) println(c2.fullName) - println(c2.typeSignature) + println(c2.info) } diff --git a/test/files/run/t5256g.scala b/test/files/run/t5256g.scala index 358c18601a..2d4c1b5068 100644 --- a/test/files/run/t5256g.scala +++ b/test/files/run/t5256g.scala @@ -9,5 +9,5 @@ object Test extends App { val c = cm.classSymbol(mutant.getClass) println(c) println(c.fullName) - println(c.typeSignature) + println(c.info) } diff --git a/test/files/run/t5256h.scala b/test/files/run/t5256h.scala index fd4ffd9b12..f58aa6dbe7 100644 --- a/test/files/run/t5256h.scala +++ b/test/files/run/t5256h.scala @@ -6,5 +6,5 @@ object Test extends App { val c = cm.classSymbol(mutant.getClass) println(c) println(c.fullName) - println(c.typeSignature) + println(c.info) } diff --git a/test/files/run/t6240-universe-code-gen.scala b/test/files/run/t6240-universe-code-gen.scala index 84691639bd..9f7061ee1b 100644 --- a/test/files/run/t6240-universe-code-gen.scala +++ b/test/files/run/t6240-universe-code-gen.scala @@ -53,7 +53,7 @@ object Test extends App { | TypeTag.Null.tpe | |${forceCode("this", JavaUniverseTpe)} - |${forceCode("definitions", DefinitionsModule.typeSignature)} + |${forceCode("definitions", DefinitionsModule.info)} |${forceCode("refChecks", typeOf[scala.reflect.internal.transform.RefChecks])} |${forceCode("uncurry", typeOf[scala.reflect.internal.transform.UnCurry])} |${forceCode("erasure", typeOf[scala.reflect.internal.transform.Erasure])} diff --git a/test/files/run/t6379/Macros_1.scala b/test/files/run/t6379/Macros_1.scala index a866438f7d..4f3daf4978 100644 --- a/test/files/run/t6379/Macros_1.scala +++ b/test/files/run/t6379/Macros_1.scala @@ -10,14 +10,14 @@ object Macros { import c.universe._ def test(sym: MethodSymbol): Unit = { println(s"uninitialized ${sym.name}: ${sym.exceptions}") - sym.typeSignature + sym.info println(s"initialized ${sym.name}: ${sym.exceptions}") } println("compile-time") test(typeOf[Closeable].declaration(TermName("close")).asMethod) test(typeOf[Product1[_]].declaration(TermName("productElement")).asMethod) - test(c.mirror.staticClass("Reader").typeSignature.declaration(TermName("read")).asMethod) + test(c.mirror.staticClass("Reader").info.decl(TermName("read")).asMethod) q"..${messages.map(msg => q"println($msg)")}" } diff --git a/test/files/run/t6379/Test_2.scala b/test/files/run/t6379/Test_2.scala index af4ec7c6d0..8e9c994654 100644 --- a/test/files/run/t6379/Test_2.scala +++ b/test/files/run/t6379/Test_2.scala @@ -10,13 +10,13 @@ class Reader(fname: String) { object Test extends App { def test(sym: MethodSymbol): Unit = { println(s"uninitialized ${sym.name}: ${sym.exceptions}") - sym.typeSignature + sym.info println(s"initialized ${sym.name}: ${sym.exceptions}") } Macros.foo println("runtime") - test(typeOf[Closeable].declaration(TermName("close")).asMethod) - test(typeOf[Product1[_]].declaration(TermName("productElement")).asMethod) - test(typeOf[Reader].declaration(TermName("read")).asMethod) + test(typeOf[Closeable].decl(TermName("close")).asMethod) + test(typeOf[Product1[_]].decl(TermName("productElement")).asMethod) + test(typeOf[Reader].decl(TermName("read")).asMethod) } diff --git a/test/files/run/t6392b.check b/test/files/run/t6392b.check index 3f191c7960..83d8fe20c1 100644 --- a/test/files/run/t6392b.check +++ b/test/files/run/t6392b.check @@ -1 +1 @@ -ModuleDef(Modifiers(), TermName("C")#MOD, Template(List(Select(Ident(scala#PK), TypeName("AnyRef")#TPE)), noSelfType, List(DefDef(Modifiers(), nme.CONSTRUCTOR#PCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(TypeName("C")), tpnme.EMPTY), nme.CONSTRUCTOR#CTOR), List())), Literal(Constant(()))))))) +ModuleDef(Modifiers(), TermName("C")#MOD, Template(List(Select(Ident(scala#PK), TypeName("AnyRef")#TPE)), noSelfType, List(DefDef(Modifiers(), termNames.CONSTRUCTOR#PCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(TypeName("C")), typeNames.EMPTY), termNames.CONSTRUCTOR#CTOR), List())), Literal(Constant(()))))))) diff --git a/test/files/run/t6394b/Macros_1.scala b/test/files/run/t6394b/Macros_1.scala index 53215e63aa..1a747816e3 100644 --- a/test/files/run/t6394b/Macros_1.scala +++ b/test/files/run/t6394b/Macros_1.scala @@ -4,7 +4,7 @@ object Macros { def impl(c:Context): c.Expr[Any] = { import c.universe._ - val selfTree = This(tpnme.EMPTY) + val selfTree = This(typeNames.EMPTY) c.Expr[AnyRef](selfTree) } diff --git a/test/files/run/t6411a.scala b/test/files/run/t6411a.scala index 3bfeac2890..46c88d9294 100644 --- a/test/files/run/t6411a.scala +++ b/test/files/run/t6411a.scala @@ -32,7 +32,7 @@ object a { object Test extends App { def test(methName: String, arg: Any) = { val moduleA = cm.reflect(a) - val msym = moduleA.symbol.typeSignature.declaration(TermName(methName)).asMethod + val msym = moduleA.symbol.info.decl(TermName(methName)).asMethod println(s"meth = $msym") val mmirror = moduleA.reflectMethod(msym) val mresult = diff --git a/test/files/run/t6411b.scala b/test/files/run/t6411b.scala index af30108826..b5c3bf8732 100644 --- a/test/files/run/t6411b.scala +++ b/test/files/run/t6411b.scala @@ -6,7 +6,7 @@ case class Bar(foo: Foo) object Test extends App { val mirror = runtimeMirror(getClass.getClassLoader) val cm = mirror.reflectClass(typeOf[Bar].typeSymbol.asClass) - val ctor = typeOf[Bar].declaration(nme.CONSTRUCTOR).asMethod + val ctor = typeOf[Bar].decl(termNames.CONSTRUCTOR).asMethod val ctorm = cm.reflectConstructor(ctor) println(ctorm(Foo(3))) }
\ No newline at end of file diff --git a/test/files/run/t6548/Test_2.scala b/test/files/run/t6548/Test_2.scala index 7200259d36..cb5abd9c39 100644 --- a/test/files/run/t6548/Test_2.scala +++ b/test/files/run/t6548/Test_2.scala @@ -8,5 +8,5 @@ class Bean { object Test extends App { println(cm.staticClass("Bean").isCaseClass) - println(typeOf[Bean].declaration(TermName("value")).annotations) + println(typeOf[Bean].decl(TermName("value")).annotations) } diff --git a/test/files/run/t6591_2.check b/test/files/run/t6591_2.check index 8c972ef920..a2930b1749 100644 --- a/test/files/run/t6591_2.check +++ b/test/files/run/t6591_2.check @@ -1 +1 @@ -Block(List(ValDef(Modifiers(), TermName("v"), SelectFromTypeTree(Ident(A), TypeName("I")), Select(Apply(Select(New(Ident(A)), nme.CONSTRUCTOR), List()), TermName("impl")))), Ident(TermName("v"))) +Block(List(ValDef(Modifiers(), TermName("v"), SelectFromTypeTree(Ident(A), TypeName("I")), Select(Apply(Select(New(Ident(A)), termNames.CONSTRUCTOR), List()), TermName("impl")))), Ident(TermName("v"))) diff --git a/test/files/run/t6591_3.check b/test/files/run/t6591_3.check index f4592adce9..362aafd11c 100644 --- a/test/files/run/t6591_3.check +++ b/test/files/run/t6591_3.check @@ -1 +1 @@ -Block(List(ValDef(Modifiers(), TermName("v"), Select(This(TypeName("A")), TypeName("I")), Apply(Select(New(Select(This(TypeName("A")), TypeName("I"))), nme.CONSTRUCTOR), List()))), Ident(TermName("v"))) +Block(List(ValDef(Modifiers(), TermName("v"), Select(This(TypeName("A")), TypeName("I")), Apply(Select(New(Select(This(TypeName("A")), TypeName("I"))), termNames.CONSTRUCTOR), List()))), Ident(TermName("v"))) diff --git a/test/files/run/t6591_7.scala b/test/files/run/t6591_7.scala index 7313a3400d..914842e613 100644 --- a/test/files/run/t6591_7.scala +++ b/test/files/run/t6591_7.scala @@ -16,8 +16,8 @@ object Test extends App { // println(expr.eval) freeTerms(expr.tree) foreach (ft => { // blocked by SI-7104, though it's not the focus of this test - // therefore I'm just commenting out the call to typeSignature - // println(s"name = ${ft.name}, sig = ${ft.typeSignature}, stable = ${ft.isStable}") + // therefore I'm just commenting out the call to info + // println(s"name = ${ft.name}, sig = ${ft.info}, stable = ${ft.isStable}") println(s"name = ${ft.name}, stable = ${ft.isStable}") }) } diff --git a/test/files/run/t6608.scala b/test/files/run/t6608.scala index 2f956bfb35..2ba979649b 100644 --- a/test/files/run/t6608.scala +++ b/test/files/run/t6608.scala @@ -7,7 +7,7 @@ class C { object Test extends App { import universe._ - val access = typeOf[C].declarations + val access = typeOf[C].decls .toList .filter(_.name.toString.endsWith("yyy")) .map(x => (x.name, x.isPrivate)) diff --git a/test/files/run/t6733.scala b/test/files/run/t6733.scala index 525b276811..df1946a9d5 100644 --- a/test/files/run/t6733.scala +++ b/test/files/run/t6733.scala @@ -31,5 +31,5 @@ trait Foo { } object Test extends App { - typeOf[Foo].declarations.sorted.foreach(m => println(s"$m: isPrivateThis = ${m.isPrivateThis}, isProtectedThis = ${m.isProtectedThis}")) + typeOf[Foo].decls.sorted.foreach(m => println(s"$m: isPrivateThis = ${m.isPrivateThis}, isProtectedThis = ${m.isProtectedThis}")) }
\ No newline at end of file diff --git a/test/files/run/t6745-2.scala b/test/files/run/t6745-2.scala index 31ecd42bd1..5afa65d28a 100644 --- a/test/files/run/t6745-2.scala +++ b/test/files/run/t6745-2.scala @@ -16,7 +16,7 @@ package context { def check(source: String, unit: global.CompilationUnit) = { val context: Context = global.analyzer.rootContext(unit) val importInfo: ImportInfo = context.imports.head // Predef._ - val importedSym = importInfo.importedSymbol(nme.CONSTRUCTOR) + val importedSym = importInfo.importedSymbol(termNames.CONSTRUCTOR) assert(importedSym == NoSymbol, importedSym) // was "constructor Predef" } } diff --git a/test/files/run/t6860.scala b/test/files/run/t6860.scala index 1391af3430..c2f8db02c2 100644 --- a/test/files/run/t6860.scala +++ b/test/files/run/t6860.scala @@ -12,7 +12,7 @@ object Test { import scala.reflect.runtime.universe._ def main(args: Array[String]): Unit = { - val members = typeOf[A].declarations.toList + val members = typeOf[A].decls.toList val tpes = members flatMap (_.annotations) map (_.tree.tpe) tpes.map(_.toString).sorted foreach println diff --git a/test/files/run/t6989/Test_2.scala b/test/files/run/t6989/Test_2.scala index 3f578158e8..932a369f6c 100644 --- a/test/files/run/t6989/Test_2.scala +++ b/test/files/run/t6989/Test_2.scala @@ -19,12 +19,12 @@ package object foo { def test(sym: Symbol): Unit = { printSymbolDetails(sym) if (sym.isClass || sym.isModule) { - sym.typeSignature.declarations.toList.sortBy(_.name.toString) foreach test + sym.info.decls.toList.sortBy(_.name.toString) foreach test } } def printSymbolDetails(sym: Symbol): Unit = { - def stableSignature(sym: Symbol) = sym.typeSignature match { + def stableSignature(sym: Symbol) = sym.info match { case ClassInfoType(_, _, _) => "ClassInfoType(...)" case tpe => tpe.toString } diff --git a/test/files/run/t6992/Macros_1.scala b/test/files/run/t6992/Macros_1.scala index d101efdda3..f578f2b3c0 100644 --- a/test/files/run/t6992/Macros_1.scala +++ b/test/files/run/t6992/Macros_1.scala @@ -13,12 +13,12 @@ object Macros { ClassDef( Modifiers(Flag.FINAL), anon, Nil, Template( Nil, noSelfType, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))), TypeDef(Modifiers(), TypeName(lit), Nil, TypeTree(typeOf[Int])) ) ) ), - Apply(Select(New(Ident(anon)), nme.CONSTRUCTOR), Nil) + Apply(Select(New(Ident(anon)), termNames.CONSTRUCTOR), Nil) )) } @@ -33,7 +33,7 @@ object Macros { ClassDef( Modifiers(Flag.FINAL), anon, Nil, Template( Nil, noSelfType, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))), DefDef( Modifiers(), TermName(lit), Nil, Nil, TypeTree(), c.literal(42).tree @@ -41,7 +41,7 @@ object Macros { ) ) ), - Apply(Select(New(Ident(anon)), nme.CONSTRUCTOR), Nil) + Apply(Select(New(Ident(anon)), termNames.CONSTRUCTOR), Nil) )) } @@ -57,7 +57,7 @@ object Macros { ClassDef( Modifiers(), anon, Nil, Template( Nil, emptyValDef, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))), DefDef( Modifiers(), TermName(lit), Nil, Nil, TypeTree(), c.literal(42).tree @@ -67,9 +67,9 @@ object Macros { ), ClassDef( Modifiers(Flag.FINAL), wrapper, Nil, - Template(Ident(anon) :: Nil, noSelfType, DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))) :: Nil) + Template(Ident(anon) :: Nil, noSelfType, DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))) :: Nil) ), - Apply(Select(New(Ident(wrapper)), nme.CONSTRUCTOR), Nil) + Apply(Select(New(Ident(wrapper)), termNames.CONSTRUCTOR), Nil) )) } }
\ No newline at end of file diff --git a/test/files/run/t6992/Test_2.scala b/test/files/run/t6992/Test_2.scala index 1ed8958d38..2399bf81df 100644 --- a/test/files/run/t6992/Test_2.scala +++ b/test/files/run/t6992/Test_2.scala @@ -4,7 +4,7 @@ object Test extends App { val foo = Macros.foo("T") val ttpe = scala.reflect.runtime.universe.weakTypeOf[foo.T] println(ttpe) - println(ttpe.typeSymbol.typeSignature) + println(ttpe.typeSymbol.info) val bar = Macros.bar("test") println(bar.test) diff --git a/test/files/run/t7008-scala-defined/Impls_Macros_2.scala b/test/files/run/t7008-scala-defined/Impls_Macros_2.scala index 7049ed6490..330db8da75 100644 --- a/test/files/run/t7008-scala-defined/Impls_Macros_2.scala +++ b/test/files/run/t7008-scala-defined/Impls_Macros_2.scala @@ -4,7 +4,7 @@ import scala.reflect.macros.blackbox.Context object Macros { def impl(c: Context) = { import c.universe._ - val decls = c.typeOf[ScalaClassWithCheckedExceptions_1[_]].declarations.toList + val decls = c.typeOf[ScalaClassWithCheckedExceptions_1[_]].decls.toList val s = decls.sortBy(_.name.toString).map(decl => (s"${decl.name}: ${decl.annotations}")).mkString(scala.compat.Platform.EOL) reify(println(c.Expr[String](Literal(Constant(s))).splice)) } diff --git a/test/files/run/t7008-scala-defined/Test_3.scala b/test/files/run/t7008-scala-defined/Test_3.scala index 03bb79d311..ee7b9d9cde 100644 --- a/test/files/run/t7008-scala-defined/Test_3.scala +++ b/test/files/run/t7008-scala-defined/Test_3.scala @@ -4,6 +4,6 @@ object Test extends App { Macros.foo println("=============") - val decls = typeOf[ScalaClassWithCheckedExceptions_1[_]].declarations.toList + val decls = typeOf[ScalaClassWithCheckedExceptions_1[_]].decls.toList decls sortBy (_.name.toString) foreach (decl => println(s"${decl.name}: ${decl.annotations}")) }
\ No newline at end of file diff --git a/test/files/run/t7008/Impls_Macros_2.scala b/test/files/run/t7008/Impls_Macros_2.scala index 9dfa66a20a..3c6fe116ce 100644 --- a/test/files/run/t7008/Impls_Macros_2.scala +++ b/test/files/run/t7008/Impls_Macros_2.scala @@ -4,7 +4,7 @@ import scala.reflect.macros.blackbox.Context object Macros { def impl(c: Context) = { import c.universe._ - val decls = c.typeOf[JavaClassWithCheckedExceptions_1[_]].declarations.toList + val decls = c.typeOf[JavaClassWithCheckedExceptions_1[_]].decls.toList val s = decls.sortBy(_.name.toString).map(decl => (s"${decl.name}: ${decl.annotations}")).mkString(scala.compat.Platform.EOL) reify(println(c.Expr[String](Literal(Constant(s))).splice)) } diff --git a/test/files/run/t7008/Test_3.scala b/test/files/run/t7008/Test_3.scala index b2961a829e..99db05e810 100644 --- a/test/files/run/t7008/Test_3.scala +++ b/test/files/run/t7008/Test_3.scala @@ -4,6 +4,6 @@ object Test extends App { Macros.foo println("=============") - val decls = typeOf[JavaClassWithCheckedExceptions_1[_]].declarations.toList + val decls = typeOf[JavaClassWithCheckedExceptions_1[_]].decls.toList decls sortBy (_.name.toString) foreach (decl => println(s"${decl.name}: ${decl.annotations}")) }
\ No newline at end of file diff --git a/test/files/run/t7045.scala b/test/files/run/t7045.scala index f41baca05e..5b31a8b779 100644 --- a/test/files/run/t7045.scala +++ b/test/files/run/t7045.scala @@ -7,6 +7,6 @@ class D { self: C => } object Test extends App { val d = cm.staticClass("D") println(d.selfType) - d.typeSignature + d.info println(d.selfType) }
\ No newline at end of file diff --git a/test/files/run/t7046.scala b/test/files/run/t7046.scala index 647a15cd18..f15545f59f 100644 --- a/test/files/run/t7046.scala +++ b/test/files/run/t7046.scala @@ -8,6 +8,6 @@ class E extends C object Test extends App { val c = cm.staticClass("C") println(c.knownDirectSubclasses) - c.typeSignature + c.info println(c.knownDirectSubclasses) }
\ No newline at end of file diff --git a/test/files/run/t7240/Macros_1.scala b/test/files/run/t7240/Macros_1.scala index c6e976038d..b24b607d17 100644 --- a/test/files/run/t7240/Macros_1.scala +++ b/test/files/run/t7240/Macros_1.scala @@ -34,11 +34,11 @@ object Bakery { List(dslTrait("bakery.FailureCake")), emptyValDef, List( - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), - Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), + Block(List(Apply(Select(Super(This(typeNames.EMPTY), typeNames.EMPTY), termNames.CONSTRUCTOR), List())), Literal(Constant(())))), DefDef(Modifiers(), newTermName("main"), List(), List(List()), Ident(newTypeName("Any")), transformedBody)))) - def constructor = Apply(Select(New(Ident(newTypeName("eval"))), nme.CONSTRUCTOR), List()) + def constructor = Apply(Select(New(Ident(newTypeName("eval"))), termNames.CONSTRUCTOR), List()) c.eval(c.Expr[Any]( c.untypecheck(Block(composeDSL(Literal(Constant(1))), constructor)))) diff --git a/test/files/run/t7328.scala b/test/files/run/t7328.scala index 8816fa2347..56956b489b 100644 --- a/test/files/run/t7328.scala +++ b/test/files/run/t7328.scala @@ -5,7 +5,7 @@ case class Foo(x: Int) extends AnyVal case class Bar(foo: Foo) object Test extends App { - val foo = typeOf[Bar].declaration(TermName("foo")).asMethod + val foo = typeOf[Bar].decl(TermName("foo")).asMethod println(foo.returnType) // Foo val bar = Bar(Foo(3)) diff --git a/test/files/run/t7331c.check b/test/files/run/t7331c.check index b35d831f83..a9dc6a7d0f 100644 --- a/test/files/run/t7331c.check +++ b/test/files/run/t7331c.check @@ -1,3 +1,3 @@ -ClassDef(Modifiers(), TypeName("C"), List(), Template(List(Select(Ident(scala), TypeName("AnyRef"))), noSelfType, List(DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))))) +ClassDef(Modifiers(), TypeName("C"), List(), Template(List(Select(Ident(scala), TypeName("AnyRef"))), noSelfType, List(DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))))) source-<toolbox>,line-1,offset=6 NoPosition diff --git a/test/files/run/t7455/Test.scala b/test/files/run/t7455/Test.scala index b23a724c78..2cda9225f4 100644 --- a/test/files/run/t7455/Test.scala +++ b/test/files/run/t7455/Test.scala @@ -21,7 +21,7 @@ object Test extends DirectTest { for { name <- Seq("Outer", "Outer$PrivateInner", "Outer$PrivateStaticInner", "Outer$PublicInner") clazz = compiler.rootMirror.staticClass(name) - constr <- clazz.info.member(nme.CONSTRUCTOR).alternatives + constr <- clazz.info.member(termNames.CONSTRUCTOR).alternatives } { println(constr.defString) fullyInitializeSymbol(constr) diff --git a/test/files/run/t7533.scala b/test/files/run/t7533.scala index 46d0b3b02e..c7bd8e8d43 100644 --- a/test/files/run/t7533.scala +++ b/test/files/run/t7533.scala @@ -29,7 +29,7 @@ object Test extends App { println(s"=======$sym=======") def printAbstract(sym: Symbol) = println(s"$sym => ${sym.isAbstract}") printAbstract(sym) - sym.typeSignature.declarations.sorted.foreach(printAbstract) + sym.info.decls.sorted.foreach(printAbstract) } test[C] test[T] diff --git a/test/files/run/t7556/Test_2.scala b/test/files/run/t7556/Test_2.scala index 31848738ef..a78c917ed8 100644 --- a/test/files/run/t7556/Test_2.scala +++ b/test/files/run/t7556/Test_2.scala @@ -5,7 +5,7 @@ object Test { val mc = new MegaClass val anns = mc.getClass.getAnnotations.map(_.annotationType.getName).toList.sorted println(s"class annotations: $anns") - val N = typeTag[MegaClass].tpe.declarations.size // was: error reading Scala signature of MegaClass: 65935 + val N = typeTag[MegaClass].tpe.decls.size // was: error reading Scala signature of MegaClass: 65935 println(s"$N decls via runtime reflection") } } diff --git a/test/files/run/t7570b.scala b/test/files/run/t7570b.scala index 9ed7c87885..7d4ade5237 100644 --- a/test/files/run/t7570b.scala +++ b/test/files/run/t7570b.scala @@ -3,11 +3,12 @@ import scala.reflect.runtime.{currentMirror => cm} import scala.tools.reflect.{ToolBox, ToolBoxError} import definitions._ import Flag._ +import internal._ object Test extends App { val tb = cm.mkToolBox() val msg = internal.reificationSupport.newFreeTerm("msg", "C") - internal.reificationSupport.setTypeSignature(msg, typeOf[String]) + internal.reificationSupport.setInfo(msg, typeOf[String]) try { val csym = tb.define(q"""class C { override def toString = $msg }""") println(tb.eval(q"new $csym")) diff --git a/test/files/run/t8104/Macros_1.scala b/test/files/run/t8104/Macros_1.scala index 2ad4bc5a99..e135bd807b 100644 --- a/test/files/run/t8104/Macros_1.scala +++ b/test/files/run/t8104/Macros_1.scala @@ -4,8 +4,8 @@ object Macros { def impl[T](c: Context)(implicit T: c.WeakTypeTag[T]) = { import c.universe._ import definitions._ - val fields = T.tpe.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } - val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.typeSignature)) + val fields = T.tpe.decls.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + val Repr = appliedType(TupleClass(fields.length).asType.toType, fields.map(_.info)) q"new Generic[$T]{ type Repr = $Repr }" } }
\ No newline at end of file diff --git a/test/files/run/t8104/Test_2.scala b/test/files/run/t8104/Test_2.scala index 55c080a563..08451dfb2a 100644 --- a/test/files/run/t8104/Test_2.scala +++ b/test/files/run/t8104/Test_2.scala @@ -11,7 +11,7 @@ object Test extends App { import scala.reflect.runtime.universe._ def reprify[T, Repr](x: T)(implicit generic: Generic.Aux[T, Repr], tag: WeakTypeTag[Repr]) = { println(tag) - println(tag.tpe.typeSymbol.typeSignature) + println(tag.tpe.typeSymbol.info) } reprify(C(40, 2)) diff --git a/test/files/run/t8192/Macros_1.scala b/test/files/run/t8192/Macros_1.scala index 2089273d6d..ddad9fb872 100644 --- a/test/files/run/t8192/Macros_1.scala +++ b/test/files/run/t8192/Macros_1.scala @@ -22,10 +22,10 @@ object Macros { if (sym == NoSymbol) "NoSymbol" else s"${defString(sym)} => ${sym.asMethod.isPrimaryConstructor}" } - sym.typeSignature + sym.info println(sym.toString) println(s"primary constructor: ${showCtor(sym.primaryConstructor)}") - val ctors = sym.typeSignature.members.filter(_.name == nme.CONSTRUCTOR).map(sym => showCtor(sym)) + val ctors = sym.info.members.filter(_.name == termNames.CONSTRUCTOR).map(sym => showCtor(sym)) ctors.toList.sorted.foreach(println) } diff --git a/test/files/run/t8192/Test_2.scala b/test/files/run/t8192/Test_2.scala index 15f684eb3f..29f187c171 100644 --- a/test/files/run/t8192/Test_2.scala +++ b/test/files/run/t8192/Test_2.scala @@ -21,10 +21,10 @@ object Test extends App { if (sym == NoSymbol) "NoSymbol" else s"${defString(sym)} => ${sym.asMethod.isPrimaryConstructor}" } - sym.typeSignature + sym.info println(sym.toString) println(s"primary constructor: ${showCtor(sym.primaryConstructor)}") - val ctors = sym.typeSignature.members.filter(_.name == nme.CONSTRUCTOR).map(sym => showCtor(sym)) + val ctors = sym.info.members.filter(_.name == termNames.CONSTRUCTOR).map(sym => showCtor(sym)) ctors.toList.sorted.foreach(println) } diff --git a/test/files/run/toolbox_typecheck_implicitsdisabled.scala b/test/files/run/toolbox_typecheck_implicitsdisabled.scala index 8c1a6e580c..3fabdb33b6 100644 --- a/test/files/run/toolbox_typecheck_implicitsdisabled.scala +++ b/test/files/run/toolbox_typecheck_implicitsdisabled.scala @@ -7,7 +7,7 @@ object Test extends App { val toolbox = cm.mkToolBox() val tree1 = Block(List( - Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))), + Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(termNames.WILDCARD, -1, null, -1)))), Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2)))) ) val ttree1 = toolbox.typecheck(tree1, withImplicitViewsDisabled = false) @@ -15,7 +15,7 @@ object Test extends App { try { val tree2 = Block(List( - Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(nme.WILDCARD, -1, null, -1)))), + Import(Select(Ident(TermName("scala")), TermName("Predef")), List(ImportSelector(termNames.WILDCARD, -1, null, -1)))), Apply(Select(Literal(Constant(1)), TermName("$minus$greater")), List(Literal(Constant(2)))) ) val ttree2 = toolbox.typecheck(tree2, withImplicitViewsDisabled = true) diff --git a/test/files/run/toolbox_typecheck_macrosdisabled.scala b/test/files/run/toolbox_typecheck_macrosdisabled.scala index ab193808ab..5466cb7765 100644 --- a/test/files/run/toolbox_typecheck_macrosdisabled.scala +++ b/test/files/run/toolbox_typecheck_macrosdisabled.scala @@ -12,9 +12,9 @@ object Test extends App { val toolbox = cm.mkToolBox() val rupkg = cm.staticModule("scala.reflect.runtime.package") val rusym = reificationSupport.selectTerm(rupkg, "universe") - val NullaryMethodType(rutpe) = rusym.typeSignature + val NullaryMethodType(rutpe) = rusym.info val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe) - reificationSupport.setTypeSignature(ru, rutpe) + reificationSupport.setInfo(ru, rutpe) val tree1 = Apply(Select(Ident(ru), TermName("reify")), List(Literal(Constant(2)))) val ttree1 = toolbox.typecheck(tree1, withMacrosDisabled = false) diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.scala b/test/files/run/toolbox_typecheck_macrosdisabled2.scala index 94b6fb9249..606d3d40cb 100644 --- a/test/files/run/toolbox_typecheck_macrosdisabled2.scala +++ b/test/files/run/toolbox_typecheck_macrosdisabled2.scala @@ -12,9 +12,9 @@ object Test extends App { val toolbox = cm.mkToolBox() val rupkg = cm.staticModule("scala.reflect.runtime.package") val rusym = reificationSupport.selectTerm(rupkg, "universe") - val NullaryMethodType(rutpe) = rusym.typeSignature + val NullaryMethodType(rutpe) = rusym.info val ru = reificationSupport.newFreeTerm("ru", scala.reflect.runtime.universe) - reificationSupport.setTypeSignature(ru, rutpe) + reificationSupport.setInfo(ru, rutpe) val tree1 = Apply(Select(Ident(ru), TermName("reify")), List(Apply(Select(Ident(TermName("scala")), TermName("Array")), List(Literal(Constant(2)))))) val ttree1 = toolbox.typecheck(tree1, withMacrosDisabled = false) diff --git a/test/files/run/typed-annotated/Macros_1.scala b/test/files/run/typed-annotated/Macros_1.scala index d805d82f39..4f0660dc45 100644 --- a/test/files/run/typed-annotated/Macros_1.scala +++ b/test/files/run/typed-annotated/Macros_1.scala @@ -6,8 +6,8 @@ class ann extends scala.annotation.StaticAnnotation object Macros { def impl(c: Context) = { import c.universe._ - // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), Ident(newTypeName("Int"))) - val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int])) + // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), termNames.CONSTRUCTOR), List()), Ident(newTypeName("Int"))) + val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), termNames.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int])) c.Expr[Unit](Block( List(ValDef(Modifiers(), newTermName("x"), tpt, Literal(Constant(42)))), Apply(Ident(newTermName("println")), List(Ident(newTermName("x")))))) diff --git a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala index 618ea5be11..0e0e70fd62 100644 --- a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala @@ -27,7 +27,7 @@ object DefinitionConstructionProps trait ClassConstruction { self: QuasiquoteProperties => val anyRef = ScalaDot(TypeName("AnyRef")) val emtpyConstructor = - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(())))) def classWith(name: TypeName, parents: List[Tree] = List(anyRef), body: List[DefDef] = Nil) = ClassDef( @@ -173,7 +173,7 @@ trait TypeDefConstruction { self: QuasiquoteProperties => TypeDef( Modifiers(), T, List(), CompoundTypeTree( - Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), nme.WILDCARD, TypeTree(), EmptyTree), List()))) + Template(List(Ident(A), Ident(B)), ValDef(Modifiers(PRIVATE), termNames.WILDCARD, TypeTree(), EmptyTree), List()))) } property("splice trees into existential type tree") = forAll { @@ -242,7 +242,7 @@ trait MethodConstruction { self: QuasiquoteProperties => property("splice idents into annotation") = test { val idents = List(Ident(TypeName("annot1")), Ident(TypeName("annot2"))) assertSameAnnots(q"@..$idents def foo", - idents.map { ident => Apply(Select(New(ident), nme.CONSTRUCTOR), List()) }) + idents.map { ident => Apply(Select(New(ident), termNames.CONSTRUCTOR), List()) }) } property("splice constructor calls into annotation") = test { diff --git a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala index e9337bc584..512b81c0e6 100644 --- a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala @@ -102,7 +102,7 @@ trait ClassDeconstruction { self: QuasiquoteProperties => noSelfType, List( //ValDef(Modifiers(PRIVATE | LOCAL | PARAMACCESSOR), TermName("x"), Ident(TypeName("Int")), EmptyTree), - DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List(ValDef(Modifiers(PARAM | PARAMACCESSOR), TermName("x"), + DefDef(Modifiers(), termNames.CONSTRUCTOR, List(), List(List(ValDef(Modifiers(PARAM | PARAMACCESSOR), TermName("x"), Ident(TypeName("Int")), EmptyTree))), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))))) } } @@ -117,7 +117,7 @@ trait ModsDeconstruction { self: QuasiquoteProperties => property("@$annot def foo") = forAll { (annotName: TypeName) => val q"@$annot def foo" = q"@$annotName def foo" - annot ≈ Apply(Select(New(Ident(annotName)), nme.CONSTRUCTOR), List()) + annot ≈ Apply(Select(New(Ident(annotName)), termNames.CONSTRUCTOR), List()) } property("@$annot(..$args) def foo") = forAll { (annotName: TypeName, tree: Tree) => @@ -269,6 +269,6 @@ trait ImportDeconstruction { self: QuasiquoteProperties => q"import $expr.{$plain, $oldname => $newname, $discard => _}" expr1 ≈ expr && plain11 == plain12 && plain12 == plain && - oldname1 == oldname && newname1 == newname && discard1 == discard && wildcard == nme.WILDCARD + oldname1 == oldname && newname1 == newname && discard1 == discard && wildcard == termNames.WILDCARD } } diff --git a/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala b/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala index ca4c8609ac..fffaf1b363 100644 --- a/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/PatternConstructionProps.scala @@ -7,7 +7,7 @@ object PatternConstructionProps extends QuasiquoteProperties("pattern constructi } property("splice name into bind") = forAll { (name: TermName) => - pq"$name" ≈ Bind(name, Ident(nme.WILDCARD)) + pq"$name" ≈ Bind(name, Ident(termNames.WILDCARD)) } property("splice name and tree into bind") = forAll { (name: TermName, tree: Tree) => @@ -15,11 +15,11 @@ object PatternConstructionProps extends QuasiquoteProperties("pattern constructi } property("splice type name into typed") = forAll { (name: TypeName) => - pq"_ : $name" ≈ Typed(Ident(nme.WILDCARD), Ident(name)) + pq"_ : $name" ≈ Typed(Ident(termNames.WILDCARD), Ident(name)) } property("splice tree into typed") = forAll { (typ: Tree) => - pq"_ : $typ" ≈ Typed(Ident(nme.WILDCARD), typ) + pq"_ : $typ" ≈ Typed(Ident(termNames.WILDCARD), typ) } property("splice into apply") = forAll { (pat: Tree, subpat: Tree) => diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala index 058880a25c..400e1ac9fd 100644 --- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala @@ -46,7 +46,7 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") { property("splice tree into new") = forAll { (tree: Tree) => - q"new $tree" ≈ Apply(Select(New(tree), nme.CONSTRUCTOR), List()) + q"new $tree" ≈ Apply(Select(New(tree), termNames.CONSTRUCTOR), List()) } property("splice tree into return") = forAll { (tree: Tree) => |