Merge pull request #4318 from soc/topic/remove-deprecation-warnings

Remove deprecation warnings

13 files changed, 42 insertions, 44 deletions

diff --git a/src/reflect/scala/reflect/api/Names.scala b/src/reflect/scala/reflect/api/Names.scala
index 472da60338..cc01225287 100644
--- a/src/reflect/scala/reflect/api/Names.scala
+++ b/src/reflect/scala/reflect/api/Names.scala
@@ -30,15 +30,15 @@ import scala.language.implicitConversions
  */
 trait Names {
   /** An implicit conversion from String to TermName.
-   *  Enables an alternative notation `"map": TermName` as opposed to `TermName("map")`.
-   *  @group Names
+   * Enables an alternative notation `"map": TermName` as opposed to `TermName("map")`.
+   * @group Names
    */
   @deprecated("Use explicit `TermName(s)` instead", "2.11.0")
   implicit def stringToTermName(s: String): TermName = TermName(s)
 
   /** An implicit conversion from String to TypeName.
-   *  Enables an alternative notation `"List": TypeName` as opposed to `TypeName("List")`.
-   *  @group Names
+   * Enables an alternative notation `"List": TypeName` as opposed to `TypeName("List")`.
+   * @group Names
    */
   @deprecated("Use explicit `TypeName(s)` instead", "2.11.0")
   implicit def stringToTypeName(s: String): TypeName = TypeName(s)
diff --git a/src/reflect/scala/reflect/api/StandardLiftables.scala b/src/reflect/scala/reflect/api/StandardLiftables.scala
index 66ac62cc9e..ebf15e4f57 100644
--- a/src/reflect/scala/reflect/api/StandardLiftables.scala
+++ b/src/reflect/scala/reflect/api/StandardLiftables.scala
@@ -230,6 +230,6 @@ trait StandardLiftables { self: Universe =>
     val Symbol     = TermName("Symbol")
     val util       = TermName("util")
     val Vector     = TermName("Vector")
-    val WILDCARD   = self.nme.WILDCARD
+    val WILDCARD   = self.termNames.WILDCARD
   }
 }
diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala
index 9ecd87c17e..2bf407ee19 100644
--- a/src/reflect/scala/reflect/api/Trees.scala
+++ b/src/reflect/scala/reflect/api/Trees.scala
@@ -2661,7 +2661,7 @@ trait Trees { self: Universe =>
    *  @group Traversal
    */
   abstract class ModifiersExtractor {
-    def apply(): Modifiers = Modifiers(NoFlags, tpnme.EMPTY, List())
+    def apply(): Modifiers = Modifiers(NoFlags, typeNames.EMPTY, List())
     def apply(flags: FlagSet, privateWithin: Name, annotations: List[Tree]): Modifiers
     def unapply(mods: Modifiers): Option[(FlagSet, Name, List[Tree])]
   }
@@ -2674,7 +2674,7 @@ trait Trees { self: Universe =>
   /** The factory for `Modifiers` instances.
    *  @group Traversal
    */
-  def Modifiers(flags: FlagSet): Modifiers = Modifiers(flags, tpnme.EMPTY)
+  def Modifiers(flags: FlagSet): Modifiers = Modifiers(flags, typeNames.EMPTY)
 
   /** An empty `Modifiers` object: no flags, empty visibility annotation and no Scala annotations.
    *  @group Traversal
diff --git a/src/reflect/scala/reflect/api/Types.scala b/src/reflect/scala/reflect/api/Types.scala
index f6995dd5de..cd7648a44a 100644
--- a/src/reflect/scala/reflect/api/Types.scala
+++ b/src/reflect/scala/reflect/api/Types.scala
@@ -469,7 +469,7 @@ trait Types {
     def unapply(tpe: SingleType): Option[(Type, Symbol)]
 
     /** @see [[InternalApi.singleType]] */
-    @deprecated("Use `ClassSymbol.thisPrefix` or `internal.singleType` instead")
+    @deprecated("Use `ClassSymbol.thisPrefix` or `internal.singleType` instead", "2.11.0")
     def apply(pre: Type, sym: Symbol)(implicit token: CompatToken): Type = internal.singleType(pre, sym)
   }
 
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 9f4ec3e6d1..756ed870ca 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -156,11 +156,11 @@ trait Definitions extends api.StandardDefinitions {
 
     // It becomes tricky to create dedicated objects for other symbols because
     // of initialization order issues.
-    lazy val JavaLangPackage      = getPackage("java.lang")
+    lazy val JavaLangPackage      = getPackage(TermName("java.lang"))
     lazy val JavaLangPackageClass = JavaLangPackage.moduleClass.asClass
-    lazy val ScalaPackage         = getPackage("scala")
+    lazy val ScalaPackage         = getPackage(TermName("scala"))
     lazy val ScalaPackageClass    = ScalaPackage.moduleClass.asClass
-    lazy val RuntimePackage       = getPackage("scala.runtime")
+    lazy val RuntimePackage       = getPackage(TermName("scala.runtime"))
     lazy val RuntimePackageClass  = RuntimePackage.moduleClass.asClass
 
     def javaTypeToValueClass(jtype: Class[_]): Symbol = jtype match {
@@ -453,7 +453,7 @@ trait Definitions extends api.StandardDefinitions {
 
     // XML
     lazy val ScalaXmlTopScope = getModuleIfDefined("scala.xml.TopScope")
-    lazy val ScalaXmlPackage  = getPackageIfDefined("scala.xml")
+    lazy val ScalaXmlPackage  = getPackageIfDefined(TermName("scala.xml"))
 
     // scala.reflect
     lazy val ReflectPackage              = requiredModule[scala.reflect.`package`.type]
@@ -1148,7 +1148,7 @@ trait Definitions extends api.StandardDefinitions {
       // Trying to allow for deprecated locations
       sym.isAliasType && isMetaAnnotation(sym.info.typeSymbol)
     )
-    lazy val metaAnnotations: Set[Symbol] = getPackage("scala.annotation.meta").info.members filter (_ isSubClass StaticAnnotationClass) toSet
+    lazy val metaAnnotations: Set[Symbol] = getPackage(TermName("scala.annotation.meta")).info.members filter (_ isSubClass StaticAnnotationClass) toSet
 
     // According to the scala.annotation.meta package object:
     // * By default, annotations on (`val`-, `var`- or plain) constructor parameters
@@ -1462,7 +1462,7 @@ trait Definitions extends api.StandardDefinitions {
       )
       lazy val TagSymbols = TagMaterializers.keySet
       lazy val Predef_conforms     = (getMemberIfDefined(PredefModule, nme.conforms)
-                               orElse getMemberMethod(PredefModule, "conforms": TermName)) // TODO: predicate on -Xsource:2.10 (for now, needed for transition from M8 -> RC1)
+                               orElse getMemberMethod(PredefModule, TermName("conforms"))) // TODO: predicate on -Xsource:2.10 (for now, needed for transition from M8 -> RC1)
       lazy val Predef_classOf      = getMemberMethod(PredefModule, nme.classOf)
       lazy val Predef_implicitly   = getMemberMethod(PredefModule, nme.implicitly)
       lazy val Predef_wrapRefArray = getMemberMethod(PredefModule, nme.wrapRefArray)
diff --git a/src/reflect/scala/reflect/internal/Importers.scala b/src/reflect/scala/reflect/internal/Importers.scala
index dc4ad25ef2..494f62af06 100644
--- a/src/reflect/scala/reflect/internal/Importers.scala
+++ b/src/reflect/scala/reflect/internal/Importers.scala
@@ -301,7 +301,7 @@ trait Importers { to: SymbolTable =>
           case (their: from.TypeTree, my: to.TypeTree) =>
             if (their.wasEmpty) my.defineType(importType(their.tpe)) else my.setType(importType(their.tpe))
           case (_, _) =>
-            my.tpe = importType(their.tpe)
+            my.setType(importType(their.tpe))
         }
       }
     }
diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index 98b2c48379..b44c4022f6 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -1006,7 +1006,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
           printSuper(st, printedName(qual), checkSymbol = false)
 
         case th @ This(qual) =>
-          if (tree.hasExistingSymbol && tree.symbol.isPackage) print(tree.symbol.fullName)
+          if (tree.hasExistingSymbol && tree.symbol.hasPackageFlag) print(tree.symbol.fullName)
           else printThis(th, printedName(qual))
 
         // remove this prefix from constructor invocation in typechecked trees: this.this -> this
@@ -1023,7 +1023,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
             }) && (tr match { // check that Select contains package
               case Select(q, _) => checkRootPackage(q)
               case _: Ident | _: This => val sym = tr.symbol
-                tr.hasExistingSymbol && sym.isPackage && sym.name != nme.ROOTPKG
+                tr.hasExistingSymbol && sym.hasPackageFlag && sym.name != nme.ROOTPKG
               case _ => false
             })
 
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index d23a102b28..d85ec22a84 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -155,11 +155,11 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def toTypeConstructor: Type = typeConstructor
     def setAnnotations(annots: AnnotationInfo*): this.type = { setAnnotations(annots.toList); this }
 
-    def getter: Symbol = getter(owner)
-    def setter: Symbol = setter(owner)
+    def getter: Symbol = getterIn(owner)
+    def setter: Symbol = setterIn(owner)
 
     def companion: Symbol = {
-      if (isModule && !isPackage) companionSymbol
+      if (isModule && !hasPackageFlag) companionSymbol
       else if (isModuleClass && !isPackageClass) sourceModule.companionSymbol
       else if (isClass && !isModuleClass && !isPackageClass) companionSymbol
       else NoSymbol
@@ -1047,7 +1047,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def isIncompleteIn(base: Symbol): Boolean =
       this.isDeferred ||
       (this hasFlag ABSOVERRIDE) && {
-        val supersym = superSymbol(base)
+        val supersym = superSymbolIn(base)
         supersym == NoSymbol || supersym.isIncompleteIn(base)
       }
 
@@ -2375,13 +2375,13 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         Nil
     )
 
+    @deprecated("Use `superSymbolIn` instead", "2.11.0")
+    final def superSymbol(base: Symbol): Symbol = superSymbolIn(base)
+
     /** The symbol accessed by a super in the definition of this symbol when
      *  seen from class `base`. This symbol is always concrete.
      *  pre: `this.owner` is in the base class sequence of `base`.
      */
-    @deprecated("Use `superSymbolIn` instead", "2.11.0")
-    final def superSymbol(base: Symbol): Symbol = superSymbolIn(base)
-
     final def superSymbolIn(base: Symbol): Symbol = {
       var bcs = base.info.baseClasses dropWhile (owner != _) drop 1
       var sym: Symbol = NoSymbol
@@ -2393,12 +2393,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       sym
     }
 
-    /** The getter of this value or setter definition in class `base`, or NoSymbol if
-     *  none exists.
-     */
     @deprecated("Use `getterIn` instead", "2.11.0")
     final def getter(base: Symbol): Symbol = getterIn(base)
 
+    /** The getter of this value or setter definition in class `base`, or NoSymbol if none exists. */
     final def getterIn(base: Symbol): Symbol =
       base.info decl getterName filter (_.hasAccessorFlag)
 
@@ -2406,11 +2404,11 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def setterName: TermName = name.setterName
     def localName: TermName  = name.localName
 
-    /** The setter of this value or getter definition, or NoSymbol if none exists */
     @deprecated("Use `setterIn` instead", "2.11.0")
     final def setter(base: Symbol, hasExpandedName: Boolean = needsExpandedSetterName): Symbol =
       setterIn(base, hasExpandedName)
 
+    /** The setter of this value or getter definition, or NoSymbol if none exists. */
     final def setterIn(base: Symbol, hasExpandedName: Boolean = needsExpandedSetterName): Symbol =
       base.info decl setterNameInBase(base, hasExpandedName) filter (_.hasAccessorFlag)
 
@@ -2538,7 +2536,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         else if (isInstanceOf[FreeTermSymbol]) ("free term", "free term", "FTE")
         else if (isInstanceOf[FreeTypeSymbol]) ("free type", "free type", "FTY")
         else if (isPackageClass) ("package class", "package", "PKC")
-        else if (isPackage) ("package", "package", "PK")
+        else if (hasPackageFlag) ("package", "package", "PK")
         else if (isPackageObject) ("package object", "package", "PKO")
         else if (isPackageObjectClass) ("package object class", "package", "PKOC")
         else if (isAnonymousClass) ("anonymous class", "anonymous class", "AC")
@@ -2822,7 +2820,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def outerSource: Symbol =
       // SI-6888 Approximate the name to workaround the deficiencies in `nme.originalName`
       //         in the face of classes named '$'. SI-2806 remains open to address the deeper problem.
-      if (originalName endsWith (nme.OUTER)) initialize.referenced
+      if (unexpandedName endsWith (nme.OUTER)) initialize.referenced
       else NoSymbol
 
     def setModuleClass(clazz: Symbol): TermSymbol = {
@@ -2852,8 +2850,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           accessed.expandName(base)
         }
         else if (hasGetter) {
-          getter(owner).expandName(base)
-          setter(owner).expandName(base)
+          getterIn(owner).expandName(base)
+          setterIn(owner).expandName(base)
         }
         name = nme.expandedName(name.toTermName, base)
       }
diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala
index b3e11a826e..75a1969d22 100644
--- a/src/reflect/scala/reflect/internal/TreeGen.scala
+++ b/src/reflect/scala/reflect/internal/TreeGen.scala
@@ -362,7 +362,7 @@ abstract class TreeGen {
         if (body forall treeInfo.isInterfaceMember) None
         else Some(
           atPos(wrappingPos(superPos, lvdefs)) (
-            DefDef(NoMods, nme.MIXIN_CONSTRUCTOR, Nil, ListOfNil, TypeTree(), Block(lvdefs, Literal(Constant())))))
+            DefDef(NoMods, nme.MIXIN_CONSTRUCTOR, Nil, ListOfNil, TypeTree(), Block(lvdefs, Literal(Constant(()))))))
       }
       else {
         // convert (implicit ... ) to ()(implicit ... ) if its the only parameter section
@@ -376,7 +376,7 @@ abstract class TreeGen {
                                          // therefore here we emit a dummy which gets populated when the template is named and typechecked
         Some(
           atPos(wrappingPos(superPos, lvdefs ::: vparamss1.flatten).makeTransparent) (
-            DefDef(constrMods, nme.CONSTRUCTOR, List(), vparamss1, TypeTree(), Block(lvdefs ::: List(superCall), Literal(Constant())))))
+            DefDef(constrMods, nme.CONSTRUCTOR, List(), vparamss1, TypeTree(), Block(lvdefs ::: List(superCall), Literal(Constant(()))))))
       }
     }
     constr foreach (ensureNonOverlapping(_, parents ::: gvdefs, focus = false))
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index fd918b8595..e3f95f9fd8 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -87,7 +87,7 @@ trait Trees extends api.Trees {
 
     private[scala] def copyAttrs(tree: Tree): this.type = {
       rawatt = tree.rawatt
-      tpe = tree.tpe
+      setType(tree.tpe)
       if (hasSymbolField) symbol = tree.symbol
       this
     }
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 8f114caac0..86a53a1b02 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -209,7 +209,7 @@ trait Types
 
   case object UnmappableTree extends TermTree {
     override def toString = "<unmappable>"
-    super.tpe_=(NoType)
+    super.setType(NoType)
     override def tpe_=(t: Type) = if (t != NoType) {
       throw new UnsupportedOperationException("tpe_=("+t+") inapplicable for <empty>")
     }
@@ -247,7 +247,7 @@ trait Types
 
     def companion = {
       val sym = typeSymbolDirect
-      if (sym.isModule && !sym.isPackage) sym.companionSymbol.tpe
+      if (sym.isModule && !sym.hasPackageFlag) sym.companionSymbol.tpe
       else if (sym.isModuleClass && !sym.isPackageClass) sym.sourceModule.companionSymbol.tpe
       else if (sym.isClass && !sym.isModuleClass && !sym.isPackageClass) sym.companionSymbol.info
       else NoType
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index 3b497227e7..6efac6d873 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -142,7 +142,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
       object ConstantArg {
         def enumToSymbol(enum: Enum[_]): Symbol = {
           val staticPartOfEnum = classToScala(enum.getClass).companionSymbol
-          staticPartOfEnum.info.declaration(enum.name: TermName)
+          staticPartOfEnum.info.declaration(TermName(enum.name))
         }
 
         def unapply(schemaAndValue: (jClass[_], Any)): Option[Any] = schemaAndValue match {
@@ -172,7 +172,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
       // currently I'm simply sorting the methods to guarantee stability of the output
       override lazy val assocs: List[(Name, ClassfileAnnotArg)] = (
         jann.annotationType.getDeclaredMethods.sortBy(_.getName).toList map (m =>
-          (m.getName: TermName) -> toAnnotArg(m.getReturnType -> m.invoke(jann))
+          TermName(m.getName) -> toAnnotArg(m.getReturnType -> m.invoke(jann))
         )
       )
     }
@@ -940,7 +940,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
       val ownerModule: ModuleSymbol =
         if (split > 0) packageNameToScala(fullname take split) else this.RootPackage
       val owner = ownerModule.moduleClass
-      val name = (fullname: TermName) drop split + 1
+      val name = TermName(fullname) drop split + 1
       val opkg = owner.info decl name
       if (opkg.hasPackageFlag)
         opkg.asModule
@@ -991,7 +991,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
               if (name.startsWith(nme.NAME_JOIN_STRING)) coreLookup(name drop 1) else NoSymbol
             }
           if (nme.isModuleName(simpleName))
-            coreLookup(nme.stripModuleSuffix(simpleName).toTermName) map (_.moduleClass)
+            coreLookup(simpleName.dropModule.toTermName) map (_.moduleClass)
           else
             coreLookup(simpleName)
         }
diff --git a/src/reflect/scala/reflect/runtime/package.scala b/src/reflect/scala/reflect/runtime/package.scala
index e240bed0a7..77eb610a84 100644
--- a/src/reflect/scala/reflect/runtime/package.scala
+++ b/src/reflect/scala/reflect/runtime/package.scala
@@ -30,9 +30,9 @@ package runtime {
       import c.universe._
       val runtimeClass = c.reifyEnclosingRuntimeClass
       if (runtimeClass.isEmpty) c.abort(c.enclosingPosition, "call site does not have an enclosing class")
-      val scalaPackage = Select(Ident(newTermName("_root_")), newTermName("scala"))
-      val runtimeUniverse = Select(Select(Select(scalaPackage, newTermName("reflect")), newTermName("runtime")), newTermName("universe"))
-      val currentMirror = Apply(Select(runtimeUniverse, newTermName("runtimeMirror")), List(Select(runtimeClass, newTermName("getClassLoader"))))
+      val scalaPackage = Select(Ident(TermName("_root_")), TermName("scala"))
+      val runtimeUniverse = Select(Select(Select(scalaPackage, TermName("reflect")), TermName("runtime")), TermName("universe"))
+      val currentMirror = Apply(Select(runtimeUniverse, TermName("runtimeMirror")), List(Select(runtimeClass, TermName("getClassLoader"))))
       c.Expr[Nothing](currentMirror)(c.WeakTypeTag.Nothing)
     }
   }