Merge pull request #1340 from gkossakowski/revert-static-annotation

Revert `@static` annotation

27 files changed, 36 insertions, 722 deletions

diff --git a/lib/scala-compiler-src.jar.desired.sha1 b/lib/scala-compiler-src.jar.desired.sha1
index 057d6b26e6..5d32ff0d1d 100644
--- a/lib/scala-compiler-src.jar.desired.sha1
+++ b/lib/scala-compiler-src.jar.desired.sha1
@@ -1 +1 @@
-acfbbb4117b222b488226b4a89d5e732eb59f19c ?scala-compiler-src.jar
+2698ecddfcde060a5db2a37e4aa448f4ad5c5891 ?scala-compiler-src.jar
diff --git a/lib/scala-compiler.jar.desired.sha1 b/lib/scala-compiler.jar.desired.sha1
index d4cad8f868..1a65697c88 100644
--- a/lib/scala-compiler.jar.desired.sha1
+++ b/lib/scala-compiler.jar.desired.sha1
@@ -1 +1 @@
-e0c0f2326622f535aa86978dee74dc7ac86e401b ?scala-compiler.jar
+d9ce03a6d3d33234d94577b0cc0093f7a1739d95 ?scala-compiler.jar
diff --git a/lib/scala-library-src.jar.desired.sha1 b/lib/scala-library-src.jar.desired.sha1
index c8515e61de..3175dc3d30 100644
--- a/lib/scala-library-src.jar.desired.sha1
+++ b/lib/scala-library-src.jar.desired.sha1
@@ -1 +1 @@
-52b0ea12b0fe6c2150434fdda3909c2aa927a325 ?scala-library-src.jar
+a06b6e42d646e7077325fe1147f1fc9fa22aad7b ?scala-library-src.jar
diff --git a/lib/scala-library.jar.desired.sha1 b/lib/scala-library.jar.desired.sha1
index 323d3441f8..1543a18c53 100644
--- a/lib/scala-library.jar.desired.sha1
+++ b/lib/scala-library.jar.desired.sha1
@@ -1 +1 @@
-7a35fcd17b39ea1e13cc8c919e1e556eed81e799 ?scala-library.jar
+4b0516ead118899611bbf6b1b21bf7a32e1f1f40 ?scala-library.jar
diff --git a/lib/scala-reflect-src.jar.desired.sha1 b/lib/scala-reflect-src.jar.desired.sha1
index 839d77da3a..7dd29fc0bb 100644
--- a/lib/scala-reflect-src.jar.desired.sha1
+++ b/lib/scala-reflect-src.jar.desired.sha1
@@ -1 +1 @@
-fc25fdfd30959e77b85c0c7917005a83890f94a2 ?scala-reflect-src.jar
+4f474a08df49c89a04031096093a0eda7875c8b7 ?scala-reflect-src.jar
diff --git a/lib/scala-reflect.jar.desired.sha1 b/lib/scala-reflect.jar.desired.sha1
index 88ea78c303..aaea49a8b8 100644
--- a/lib/scala-reflect.jar.desired.sha1
+++ b/lib/scala-reflect.jar.desired.sha1
@@ -1 +1 @@
-5aca838ee9d82be45fb476c1722f71842d5d528e ?scala-reflect.jar
+2a2172b2a97a0458ccce846b3a779e7728a7f034 ?scala-reflect.jar
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index bab658e141..2fa9c076dd 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -121,44 +121,26 @@ abstract class GenICode extends SubComponent  {
         m.native = m.symbol.hasAnnotation(definitions.NativeAttr)
 
         if (!m.isAbstractMethod && !m.native) {
-          val staticfield = if (m.symbol.isAccessor && m.symbol.accessed.hasStaticAnnotation) {
-            val compClass = m.symbol.owner.companionClass
-            compClass.info.findMember(m.symbol.accessed.name, NoFlags, NoFlags, false)
-          } else NoSymbol
-          if (staticfield != NoSymbol) {
-            // in companion object accessors to @static fields, we access the static field directly
-            val hostClass = m.symbol.owner.companionClass
-            if (m.symbol.isGetter) {
-              ctx1.bb.emit(LOAD_FIELD(staticfield, true) setHostClass hostClass, tree.pos)
-              ctx1.bb.closeWith(RETURN(m.returnType))
-            } else if (m.symbol.isSetter) {
-              ctx1.bb.emit(LOAD_LOCAL(m.locals.head), tree.pos)
-              ctx1.bb.emit(STORE_FIELD(staticfield, true), tree.pos)
+          ctx1 = genLoad(rhs, ctx1, m.returnType);
+
+          // reverse the order of the local variables, to match the source-order
+          m.locals = m.locals.reverse
+
+          rhs match {
+            case Block(_, Return(_)) => ()
+            case Return(_) => ()
+            case EmptyTree =>
+              globalError("Concrete method has no definition: " + tree + (
+                if (settings.debug.value) "(found: " + m.symbol.owner.info.decls.toList.mkString(", ") + ")"
+                else "")
+              )
+            case _ => if (ctx1.bb.isEmpty)
+              ctx1.bb.closeWith(RETURN(m.returnType), rhs.pos)
+            else
               ctx1.bb.closeWith(RETURN(m.returnType))
-            } else assert(false, "unreachable")
-          } else {
-            ctx1 = genLoad(rhs, ctx1, m.returnType);
-
-            // reverse the order of the local variables, to match the source-order
-            m.locals = m.locals.reverse
-
-            rhs match {
-              case Block(_, Return(_)) => ()
-              case Return(_) => ()
-              case EmptyTree =>
-                globalError("Concrete method has no definition: " + tree + (
-                  if (settings.debug.value) "(found: " + m.symbol.owner.info.decls.toList.mkString(", ") + ")"
-                  else "")
-                )
-              case _ =>
-                if (ctx1.bb.isEmpty)
-                  ctx1.bb.closeWith(RETURN(m.returnType), rhs.pos)
-                else
-                  ctx1.bb.closeWith(RETURN(m.returnType))
-            }
-            if (!ctx1.bb.closed) ctx1.bb.close
-            prune(ctx1.method)
           }
+          if (!ctx1.bb.closed) ctx1.bb.close
+          prune(ctx1.method)
         } else
           ctx1.method.setCode(NoCode)
         ctx1
@@ -900,47 +882,6 @@ abstract class GenICode extends SubComponent  {
           generatedType = toTypeKind(fun.symbol.tpe.resultType)
           ctx1
 
-        case app @ Apply(fun @ Select(qual, _), args)
-        if !ctx.method.symbol.isStaticConstructor
-        && fun.symbol.isAccessor && fun.symbol.accessed.hasStaticAnnotation
-        && qual.tpe.typeSymbol.orElse(fun.symbol.owner).companionClass != NoSymbol =>
-          // bypass the accessor to the companion object and load the static field directly
-          // this bypass is not done:
-          // - if the static intializer for the static field itself
-          // - if there is no companion class of the object owner - this happens in the REPL
-          def genLoadApply5 = {
-          val sym = fun.symbol
-          generatedType = toTypeKind(sym.accessed.info)
-          val hostOwner = qual.tpe.typeSymbol.orElse(sym.owner)
-          val hostClass = hostOwner.companionClass
-          val staticfield = hostClass.info.findMember(sym.accessed.name, NoFlags, NoFlags, false) orElse {
-            if (!currentRun.compiles(hostOwner)) {
-              // hostOwner was separately compiled -- the static field symbol needs to be recreated in hostClass
-              import Flags._
-              debuglog("recreating sym.accessed.name: " + sym.accessed.name)
-              val objectfield = hostOwner.info.findMember(sym.accessed.name, NoFlags, NoFlags, false)
-              val staticfield = hostClass.newVariable(newTermName(sym.accessed.name.toString), tree.pos, STATIC | SYNTHETIC | FINAL) setInfo objectfield.tpe
-              staticfield.addAnnotation(definitions.StaticClass)
-              hostClass.info.decls enter staticfield
-              staticfield
-            } else NoSymbol
-          }
-
-          if (sym.isGetter) {
-            ctx.bb.emit(LOAD_FIELD(staticfield, true) setHostClass hostClass, tree.pos)
-            ctx
-          } else if (sym.isSetter) {
-            val ctx1 = genLoadArguments(args, sym.info.paramTypes, ctx)
-            ctx1.bb.emit(STORE_FIELD(staticfield, true), tree.pos)
-            ctx1.bb.emit(CONSTANT(Constant(false)), tree.pos)
-            ctx1
-          } else {
-            assert(false, "supposedly unreachable")
-            ctx
-          }
-          }
-          genLoadApply5
-
         case app @ Apply(fun, args) =>
           def genLoadApply6 = {
             val sym = fun.symbol
@@ -1732,12 +1673,8 @@ abstract class GenICode extends SubComponent  {
        *  backend emits them as static).
        *  No code is needed for this module symbol.
        */
-      for (
-        f <- cls.info.decls;
-        if !f.isMethod && f.isTerm && !f.isModule && !(f.owner.isModuleClass && f.hasStaticAnnotation)
-      ) {
+      for (f <- cls.info.decls ; if !f.isMethod && f.isTerm && !f.isModule)
         ctx.clazz addField new IField(f)
-      }
     }
 
     /**
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 1653ca9c2a..28966eef08 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -1190,9 +1190,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
           log(s"No forwarder for non-public member $m")
         else {
           log("Adding static forwarder for '%s' from %s to '%s'".format(m, jclassName, moduleClass))
-          if (m.isAccessor && m.accessed.hasStaticAnnotation) {
-            log("@static: accessor " + m + ", accessed: " + m.accessed)
-          } else addForwarder(isRemoteClass, jclass, moduleClass, m)
+          addForwarder(isRemoteClass, jclass, moduleClass, m)
         }
       }
     }
@@ -1697,7 +1695,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
        	  jmethod = clinitMethod
           jMethodName = CLASS_CONSTRUCTOR_NAME
           jmethod.visitCode()
-          computeLocalVarsIndex(m)
        	  genCode(m, false, true)
           jmethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments
           jmethod.visitEnd()
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index a2151633a7..62c281b82f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -1023,8 +1023,6 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
 
        	  method = m
        	  jmethod = clinitMethod
-
-          computeLocalVarsIndex(m)
        	  genCode(m)
        	case None =>
           legacyStaticInitializer(cls, clinit)
@@ -1126,9 +1124,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
           log("No forwarder for " + m + " due to conflict with " + linkedClass.info.member(m.name))
         else {
           log("Adding static forwarder for '%s' from %s to '%s'".format(m, className, moduleClass))
-          if (m.isAccessor && m.accessed.hasStaticAnnotation) {
-            log("@static: accessor " + m + ", accessed: " + m.accessed)
-          } else addForwarder(jclass, moduleClass, m)
+          addForwarder(jclass, moduleClass, m)
         }
       }
     }
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index dff9a65649..fa7a53f888 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -23,12 +23,9 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
     new CleanUpTransformer(unit)
 
   class CleanUpTransformer(unit: CompilationUnit) extends Transformer {
-    private val newStaticMembers       = mutable.Buffer.empty[Tree]
-    private val newStaticInits         = mutable.Buffer.empty[Tree]
-    private val symbolsStoredAsStatic  = mutable.Map.empty[String, Symbol]
-    private val staticBodies           = mutable.Map.empty[(Symbol, Symbol), Tree]
-    private val syntheticClasses       = mutable.Map.empty[Symbol, mutable.Set[Tree]] // package and trees
-    private val classNames             = mutable.Map.empty[Symbol, Set[Name]]
+    private val newStaticMembers      = mutable.Buffer.empty[Tree]
+    private val newStaticInits        = mutable.Buffer.empty[Tree]
+    private val symbolsStoredAsStatic = mutable.Map.empty[String, Symbol]
     private def clearStatics() {
       newStaticMembers.clear()
       newStaticInits.clear()
@@ -48,9 +45,8 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
       result
     }
     private def transformTemplate(tree: Tree) = {
-      val t @ Template(parents, self, body) = tree
+      val Template(parents, self, body) = tree
       clearStatics()
-
       val newBody = transformTrees(body)
       val templ   = deriveTemplate(tree)(_ => transformTrees(newStaticMembers.toList) ::: newBody)
       try addStaticInits(templ) // postprocess to include static ctors
@@ -550,80 +546,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
           else tree
         }
 
-      case DefDef(mods, name, tps, vps, tp, rhs) if tree.symbol.hasStaticAnnotation =>
-        reporter.error(tree.pos, "The @static annotation is not allowed on method definitions.")
-        super.transform(tree)
-
-      case ValDef(mods, name, tpt, rhs) if tree.symbol.hasStaticAnnotation =>
-        def transformStaticValDef = {
-        log("moving @static valdef field: " + name + ", in: " + tree.symbol.owner)
-        val sym = tree.symbol
-        val owner = sym.owner
-
-        val staticBeforeLifting = atPhase(currentRun.erasurePhase) { owner.isStatic }
-        val isPrivate = atPhase(currentRun.typerPhase) { sym.getter(owner).hasFlag(PRIVATE) }
-        val isProtected = atPhase(currentRun.typerPhase) { sym.getter(owner).hasFlag(PROTECTED) }
-        val isLazy = atPhase(currentRun.typerPhase) { sym.getter(owner).hasFlag(LAZY) }
-        if (!owner.isModuleClass || !staticBeforeLifting) {
-          if (!sym.isSynthetic) {
-            reporter.error(tree.pos, "Only members of top-level objects and their nested objects can be annotated with @static.")
-            tree.symbol.removeAnnotation(StaticClass)
-          }
-          super.transform(tree)
-        } else if (isPrivate || isProtected) {
-          reporter.error(tree.pos, "The @static annotation is only allowed on public members.")
-          tree.symbol.removeAnnotation(StaticClass)
-          super.transform(tree)
-        } else if (isLazy) {
-          reporter.error(tree.pos, "The @static annotation is not allowed on lazy members.")
-          tree.symbol.removeAnnotation(StaticClass)
-          super.transform(tree)
-        } else if (owner.isModuleClass) {
-          val linkedClass = owner.companionClass match {
-            case NoSymbol =>
-              // create the companion class if it does not exist
-              val enclosing = owner.owner
-              val compclass = enclosing.newClass(newTypeName(owner.name.toString))
-              compclass setInfo ClassInfoType(List(ObjectClass.tpe), newScope, compclass)
-              enclosing.info.decls enter compclass
-
-              val compclstree = ClassDef(compclass, NoMods, ListOfNil, ListOfNil, List(), tree.pos)
-
-              syntheticClasses.getOrElseUpdate(enclosing, mutable.Set()) += compclstree
-
-              compclass
-            case comp => comp
-          }
-
-          // create a static field in the companion class for this @static field
-          val stfieldSym = linkedClass.newValue(newTermName(name), tree.pos, STATIC | SYNTHETIC | FINAL) setInfo sym.tpe
-          if (sym.isMutable) stfieldSym.setFlag(MUTABLE)
-          stfieldSym.addAnnotation(StaticClass)
-
-          val names = classNames.getOrElseUpdate(linkedClass, linkedClass.info.decls.collect {
-            case sym if sym.name.isTermName => sym.name
-          } toSet)
-          if (names(stfieldSym.name)) {
-            reporter.error(
-              tree.pos,
-              "@static annotated field " + tree.symbol.name + " has the same name as a member of class " + linkedClass.name
-            )
-          } else {
-            linkedClass.info.decls enter stfieldSym
-
-            val initializerBody = rhs
-
-            // static field was previously initialized in the companion object itself, like this:
-            //   staticBodies((linkedClass, stfieldSym)) = Select(This(owner), sym.getter(owner))
-            // instead, we move the initializer to the static ctor of the companion class
-            // we save the entire ValDef/DefDef to extract the rhs later
-            staticBodies((linkedClass, stfieldSym)) = tree
-          }
-        }
-        super.transform(tree)
-        }
-        transformStaticValDef
-
       /* MSIL requires that the stack is empty at the end of a try-block.
        * Hence, we here rewrite all try blocks with a result != {Unit, All} such that they
        * store their result in a local variable. The catch blocks are adjusted as well.
@@ -738,11 +660,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
       if (newStaticInits.isEmpty)
         template
       else {
-        val ctorBody = newStaticInits.toList flatMap {
-          case Block(stats, expr) => stats :+ expr
-          case t => List(t)
-        }
-
         val newCtor = findStaticCtor(template) match {
           // in case there already were static ctors - augment existing ones
           // currently, however, static ctors aren't being generated anywhere else
@@ -751,15 +668,15 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
             deriveDefDef(ctor) {
               case block @ Block(stats, expr) =>
                 // need to add inits to existing block
-                treeCopy.Block(block, ctorBody ::: stats, expr)
+                treeCopy.Block(block, newStaticInits.toList ::: stats, expr)
               case term: TermTree =>
                 // need to create a new block with inits and the old term
-                treeCopy.Block(term, ctorBody, term)
+                treeCopy.Block(term, newStaticInits.toList, term)
             }
           case _ =>
             // create new static ctor
             val staticCtorSym  = currentClass.newStaticConstructor(template.pos)
-            val rhs            = Block(ctorBody, Literal(Constant(())))
+            val rhs            = Block(newStaticInits.toList, Literal(Constant(())))
 
             localTyper.typedPos(template.pos)(DefDef(staticCtorSym, rhs))
         }
@@ -767,62 +684,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
       }
     }
 
-    private def addStaticDeclarations(tree: Template, clazz: Symbol) {
-      // add static field initializer statements for each static field in clazz
-      if (!clazz.isModuleClass) for {
-        staticSym <- clazz.info.decls
-        if staticSym.hasStaticAnnotation
-      } staticSym match {
-        case stfieldSym if (stfieldSym.isValue && !stfieldSym.isMethod) || stfieldSym.isVariable =>
-          log(stfieldSym + " is value: " + stfieldSym.isValue)
-          val valdef = staticBodies((clazz, stfieldSym))
-          val ValDef(_, _, _, rhs) = valdef
-          val fixedrhs = rhs.changeOwner((valdef.symbol, clazz.info.decl(nme.CONSTRUCTOR)))
-
-          val stfieldDef  = localTyper.typedPos(tree.pos)(VAL(stfieldSym) === EmptyTree)
-          val flattenedInit = fixedrhs match {
-            case Block(stats, expr) => Block(stats, REF(stfieldSym) === expr)
-            case rhs => REF(stfieldSym) === rhs
-          }
-          val stfieldInit = localTyper.typedPos(tree.pos)(flattenedInit)
-
-          // add field definition to new defs
-          newStaticMembers append stfieldDef
-          newStaticInits append stfieldInit
-        case _ => // ignore @static on other members
-      }
-    }
-
-
-
-    override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] = {
-      super.transformStats(stats, exprOwner) ++ {
-        // flush pending synthetic classes created in this owner
-        val synthclassdefs = syntheticClasses.get(exprOwner).toList.flatten
-        syntheticClasses -= exprOwner
-        synthclassdefs map {
-          cdef => localTyper.typedPos(cdef.pos)(cdef)
-        }
-      } map {
-        case clsdef @ ClassDef(mods, name, tparams, t @ Template(parent, self, body)) =>
-          // process all classes in the package again to add static initializers
-          clearStatics()
-
-          addStaticDeclarations(t, clsdef.symbol)
-
-          val templ  = deriveTemplate(t)(_ => transformTrees(newStaticMembers.toList) ::: body)
-          val ntempl =
-            try addStaticInits(templ)
-            finally clearStatics()
-
-          val derived = deriveClassDef(clsdef)(_ => ntempl)
-          classNames.remove(clsdef.symbol)
-          derived
-
-        case stat => stat
-      }
-    }
-
   } // CleanUpTransformer
 
 }
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index afc109c47a..23b15a9033 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -186,15 +186,12 @@ abstract class Constructors extends Transform with ast.TreeDSL {
           // before the superclass constructor call, otherwise it goes after.
           // Lazy vals don't get the assignment in the constructor.
           if (!stat.symbol.tpe.isInstanceOf[ConstantType]) {
-            if (stat.symbol.hasStaticAnnotation) {
-              debuglog("@static annotated field initialization skipped.")
-              defBuf += deriveValDef(stat)(tree => tree)
-            } else if (rhs != EmptyTree && !stat.symbol.isLazy) {
+            if (rhs != EmptyTree && !stat.symbol.isLazy) {
               val rhs1 = intoConstructor(stat.symbol, rhs);
               (if (canBeMoved(stat)) constrPrefixBuf else constrStatBuf) += mkAssign(
                 stat.symbol, rhs1)
-              defBuf += deriveValDef(stat)(_ => EmptyTree)
             }
+            defBuf += deriveValDef(stat)(_ => EmptyTree)
           }
         case ClassDef(_, _, _, _) =>
           // classes are treated recursively, and left in the template
diff --git a/src/library/scala/annotation/static.scala b/src/library/scala/annotation/static.scala
deleted file mode 100644
index f2955c756c..0000000000
--- a/src/library/scala/annotation/static.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.annotation
-
-/**
- * An annotation that marks a member in the companion object as static
- * and ensures that the compiler generates static fields/methods for it.
- * This is important for Java interoperability and performance reasons.
- *
- * @since 2.10
- */
-final class static extends StaticAnnotation {
-  // TODO document exact semantics above!
-}
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 4a5ace4248..48a658192b 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -932,7 +932,6 @@ trait Definitions extends api.StandardDefinitions {
     lazy val SwitchClass                = requiredClass[scala.annotation.switch]
     lazy val TailrecClass               = requiredClass[scala.annotation.tailrec]
     lazy val VarargsClass               = requiredClass[scala.annotation.varargs]
-    lazy val StaticClass                = requiredClass[scala.annotation.static]
     lazy val uncheckedStableClass       = requiredClass[scala.annotation.unchecked.uncheckedStable]
     lazy val uncheckedVarianceClass     = requiredClass[scala.annotation.unchecked.uncheckedVariance]
 
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 22f5b391b8..2f305296f5 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -246,7 +246,6 @@ trait StdNames {
     final val BeanPropertyAnnot: NameType = "BeanProperty"
     final val BooleanBeanPropertyAnnot: NameType = "BooleanBeanProperty"
     final val bridgeAnnot: NameType = "bridge"
-    final val staticAnnot: NameType = "static"
 
     // Classfile Attributes
     final val AnnotationDefaultATTR: NameType      = "AnnotationDefault"
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index b04cf4ff9f..74f4769fec 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -697,7 +697,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       || hasAnnotation(SerializableAttr) // last part can be removed, @serializable annotation is deprecated
     )
     def hasBridgeAnnotation = hasAnnotation(BridgeClass)
-    def hasStaticAnnotation = hasAnnotation(StaticClass)
     def isDeprecated        = hasAnnotation(DeprecatedAttr)
     def deprecationMessage  = getAnnotation(DeprecatedAttr) flatMap (_ stringArg 0)
     def deprecationVersion  = getAnnotation(DeprecatedAttr) flatMap (_ stringArg 1)
diff --git a/test/files/neg/static-annot.check b/test/files/neg/static-annot.check
deleted file mode 100644
index c98e7d9658..0000000000
--- a/test/files/neg/static-annot.check
+++ /dev/null
@@ -1,22 +0,0 @@
-static-annot.scala:8: error: Only members of top-level objects and their nested objects can be annotated with @static.
-  @static val bar = 1
-              ^
-static-annot.scala:27: error: @static annotated field bar  has the same name as a member of class Conflicting
-  @static val bar = 1
-              ^
-static-annot.scala:37: error: The @static annotation is only allowed on public members.
-  @static private val bar = 1
-                      ^
-static-annot.scala:38: error: The @static annotation is only allowed on public members.
-  @static private val baz = 2
-                      ^
-static-annot.scala:39: error: The @static annotation is not allowed on lazy members.
-  @static lazy val bam = 3
-                   ^
-static-annot.scala:52: error: The @static annotation is not allowed on method definitions.
-  @static def x = 42
-              ^
-static-annot.scala:14: error: Only members of top-level objects and their nested objects can be annotated with @static.
-    @static val blah = 2
-                ^
-7 errors found
diff --git a/test/files/neg/static-annot.scala b/test/files/neg/static-annot.scala
deleted file mode 100644
index c0b5ed30d8..0000000000
--- a/test/files/neg/static-annot.scala
+++ /dev/null
@@ -1,53 +0,0 @@
-
-
-import annotation.static
-
-
-
-class StaticInClass {
-  @static val bar = 1
-}
-
-
-class NestedObjectInClass {
-  object Nested {
-    @static val blah = 2
-  }
-}
-
-
-object NestedObjectInObject {
-  object Nested {
-    @static val succeed = 3
-  }
-}
-
-
-object Conflicting {
-  @static val bar = 1
-}
-
-
-class Conflicting {
-  val bar = 45
-}
-
-
-object PrivateProtectedLazy {
-  @static private val bar = 1
-  @static private val baz = 2
-  @static lazy val bam = 3
-}
-
-
-class PrivateProtectedLazy {
-  println(PrivateProtectedLazy.bar)
-  println(PrivateProtectedLazy.baz)
-  println(PrivateProtectedLazy.bam)
-}
-
-
-class StaticDef {
-  // this should not crash the compiler
-  @static def x = 42
-}
diff --git a/test/files/neg/t4581.check b/test/files/neg/t4581.check
deleted file mode 100644
index e69de29bb2..0000000000
--- a/test/files/neg/t4581.check
+++ /dev/null
diff --git a/test/files/neg/t4581/static-declaration_1.scala b/test/files/neg/t4581/static-declaration_1.scala
deleted file mode 100644
index f9a66b29c1..0000000000
--- a/test/files/neg/t4581/static-declaration_1.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-
-
-object Constants {
-  import scala.annotation.static
-  @static val Const: Int = 0 // should generate a static final field
-  @static final val FinalConst: Int = 0 // ditto
-  @static var MutableField: Int = 0 // should not be final
-}
-
-
-
diff --git a/test/files/neg/t4581/static_2.java b/test/files/neg/t4581/static_2.java
deleted file mode 100644
index 2fd5bf1d82..0000000000
--- a/test/files/neg/t4581/static_2.java
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-
-
-public class static_2 {
-	public static void main(String[] args) {
-		Constants.Const = 17;
-		Constants.FinalConst = 99;
-		Constants.MutableField = 199;
-	}
-}
-
-
-
-
diff --git a/test/files/pos/t6294.scala b/test/files/pos/t6294.scala
deleted file mode 100644
index c6d39a9cc8..0000000000
--- a/test/files/pos/t6294.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-
-object A {
-  @annotation.static final val x = 123
-}
-
-
-object B {
-  println(A.x)
-}
-
-
-
diff --git a/test/files/run/static-annot-repl.check b/test/files/run/static-annot-repl.check
deleted file mode 100644
index 3a1532b823..0000000000
--- a/test/files/run/static-annot-repl.check
+++ /dev/null
@@ -1,38 +0,0 @@
-Type in expressions to have them evaluated.
-Type :help for more information.
-
-scala> 
-
-scala> import annotation.static
-import annotation.static
-
-scala> @static var x1 = 42
-x1: Int = 42
-
-scala> @static val x2 = 43
-x2: Int = 43
-
-scala> @static def x3 = 44
-<console>:8: error: The @static annotation is not allowed on method definitions.
-       @static def x3 = 44
-                   ^
-
-scala> x1
-res0: Int = 42
-
-scala> x2
-res1: Int = 43
-
-scala> x3
-<console>:9: error: not found: value x3
-              x3
-              ^
-
-scala> class Test {
-  @static def x = 42
-}
-<console>:9: error: The @static annotation is not allowed on method definitions.
-         @static def x = 42
-                     ^
-
-scala> 
\ No newline at end of file
diff --git a/test/files/run/static-annot-repl.scala b/test/files/run/static-annot-repl.scala
deleted file mode 100644
index 1d2e9b2d7e..0000000000
--- a/test/files/run/static-annot-repl.scala
+++ /dev/null
@@ -1,22 +0,0 @@
-
-
-
-import scala.tools.partest.ReplTest
-
-
-
-object Test extends ReplTest {
-  def code = """
-import annotation.static
-@static var x1 = 42
-@static val x2 = 43
-@static def x3 = 44
-x1
-x2
-x3
-class Test {
-  @static def x = 42
-}
-"""
-
-}
diff --git a/test/files/run/static-annot/field.scala b/test/files/run/static-annot/field.scala
deleted file mode 100644
index 8408a51800..0000000000
--- a/test/files/run/static-annot/field.scala
+++ /dev/null
@@ -1,252 +0,0 @@
-
-
-
-import java.lang.reflect.Modifier
-import annotation.static
-import reflect._
-
-
-
-/* TEST 1 */
-
-/* A @static-annotated field in the companion object should yield
- * a static field in its companion class.
- */
-object Foo {
-  @static val bar = 17
-}
-
-
-class Foo
-
-
-trait Check {
-  def checkStatic(cls: Class[_]) {
-    cls.getDeclaredFields.find(_.getName == "bar") match {
-      case Some(f) =>
-        assert(Modifier.isStatic(f.getModifiers), "no static modifier")
-      case None =>
-        assert(false, "no static field bar in class")
-    }
-  }
-  
-  def test(): Unit
-}
-
-
-object Test1 extends Check {
-  def test() {
-    checkStatic(classOf[Foo])
-    assert(Foo.bar == 17, "Companion object field should be 17.")
-  }
-}
-
-
-/* TEST 2 */
-
-class Foo2
-
-
-/** The order of declaring the class and its companion is inverted now. */
-object Foo2 {
-  @static val bar = 199
-}
-
-
-object Test2 extends Check {
-  def test() {
-    checkStatic(Class.forName("Foo3"))
-    assert(Foo3.bar == 1984, "Companion object field should be 1984.")
-  }
-}
-
-
-/* TEST 3 */
-
-/** The case where there is no explicit companion class */
-object Foo3 {
-  @static val bar = 1984
-}
-
-
-object Test3 extends Check {
-  def test() {
-    checkStatic(Class.forName("Foo3"))
-    assert(Foo3.bar == 1984, "Companion object field should be 1984.")
-  }
-}
-
-
-/* TEST 4 */
-
-/** We want to be able to generate atomic reference field updaters on the companion object
- *  so that they are created only once per class declaration, but we want them to actually
- *  be initialize __in the static initializer of the class itself__.
- *  This is extremely important, because otherwise the creation of the ARFU fails, since it uses
- *  trickery to detect the caller and compare it to the owner of the field being modified.
- *  Previously, this used to be circumvented through the use of Java base classes. A pain.
- */
-class ArfuTarget {
-  @volatile var strfield = ArfuTarget.STR
-  
-  def CAS(ov: String, nv: String): Boolean = {
-    ArfuTarget.arfu.compareAndSet(this, ov, nv)
-  }
-}
-
-
-object ArfuTarget {
-  @static val arfu = java.util.concurrent.atomic.AtomicReferenceFieldUpdater.newUpdater(classOf[ArfuTarget], classOf[String], "strfield")
-  val STR = "Some string"
-}
-
-
-object Test4 extends Check {
-  def checkArfu() {
-    val at = new ArfuTarget
-    assert(at.strfield == ArfuTarget.STR)
-    at.CAS(ArfuTarget.STR, null)
-    assert(at.strfield == null)
-  }
-  
-  def test() {
-    checkArfu()
-  }
-}
-
-
-/* TEST 5 */
-
-/** Although our main use-case is to use final static fields, we should be able to use non-final too.
- *  Here we set the static field of the class by using the setters in the companion object.
- *  It is legal to do so using the reference to `Foo` directly (in which case the callsites
- *  are rewritten to access the static field directly), or through an interface `Var` (in
- *  which case the getter and the setter for `field` access the static field in `Var`).
- */
-trait Var {
-  var field: Int
-}
-
-object VarHolder extends Var {
-  @static var field = 1
-}
-
-
-object Test5 extends Check {
-  def test() {
-    assert(VarHolder.field == 1)
-    VarHolder.field = 2
-    assert(VarHolder.field == 2)
-    val vh: Var = VarHolder
-    vh.field = 3
-    assert(vh.field == 3)
-  }
-}
-
-
-/* TEST 6 */
-
-/** Here we test flattening the static ctor body and changing the owners of local definitions. */
-object Foo6 {
-  var companionField = 101
-  @static val staticField = {
-    val intermediate = companionField + 1
-    intermediate * 2
-  }
-}
-
-
-object Test6 extends Check {
-  def test() {
-    assert(Foo6.staticField == 204)
-  }
-}
-
-
-
-/* TEST 7 */
-
-/** Here we test objects nested in top-level objects */
-object Foo7 {
-  object AndHisFriend {
-    @static val bar = "string"
-  }
-  class AndHisFriend
-
-  object AndHisLonelyFriend {
-    @static val bar = "another"
-  }
-}
-
-
-object Test7 extends Check {
-  def test() {
-    checkStatic(classOf[Foo7.AndHisFriend])
-    assert(Foo7.AndHisFriend.bar == "string")
-
-    checkStatic(Class.forName("Foo7$AndHisLonelyFriend"))
-    assert(Foo7.AndHisLonelyFriend.bar == "another")
-  }
-}
-
-
-
-/* TEST 8 */
-
-object Foo8 {
-  @static val field = 7
-  
-  val function: () => Int = () => {
-    field + 1
-  }
-  
-  val anon = new Runnable {
-    def run() {
-      assert(field == 7, "runnable asserting field is 7")
-    }
-  }
-  
-  @static var mutable = 10
-  
-  val mutation: () => Unit = () => {
-    mutable += 1
-  }
-}
-
-object Test8 {
-  def test() {
-    assert(Foo8.function() == 8, "function must return 8")
-    Foo8.anon.run()
-    assert(Foo8.mutable == 10, "mutable is 10")
-    Foo8.mutation()
-    assert(Foo8.mutable == 11, "mutable is 11")
-    Foo8.mutation()
-    assert(Foo8.mutable == 12, "mutable is 12")
-  }
-}
-
-
-
-
-/* main */
-
-object Test {
-  
-  def main(args: Array[String]) {
-    Test1.test()
-    Test2.test()
-    Test3.test()
-    Test4.test()
-    Test5.test()
-    Test6.test()
-    Test7.test()
-    Test8.test()
-  }
-  
-}
-
-
-
-
-
-
diff --git a/test/files/run/t6236.check b/test/files/run/t6236.check
deleted file mode 100644
index a0a2e88d0a..0000000000
--- a/test/files/run/t6236.check
+++ /dev/null
@@ -1,2 +0,0 @@
-353
-353
\ No newline at end of file
diff --git a/test/files/run/t6236/file_1.scala b/test/files/run/t6236/file_1.scala
deleted file mode 100644
index 92d22799fc..0000000000
--- a/test/files/run/t6236/file_1.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-package p {
-  object y {
-    object x {
-      @scala.annotation.static val foo: Int = 353
-    }
-  }
-}
diff --git a/test/files/run/t6236/file_2.scala b/test/files/run/t6236/file_2.scala
deleted file mode 100644
index 51823004ca..0000000000
--- a/test/files/run/t6236/file_2.scala
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-
-object Test {
-  def main(args: Array[String]): Unit = {
-    println(p.y.x.foo)
-    println(p.y.x.foo)
-  }
-}
-