Move partest to https://github.com/scala/scala-partest

As partest is now resolved from maven, `test/partest` uses `ant test.suite.init`
to determine the classpath (serialized to build/pack/partest.properties)
that's necessary to run `scala.tools.partest.nest.ConsoleRunner`.

Thus, partest gets exactly the same classpath, whether run from
the command line through `test/partest` or via `ant test`.

The version of partest we're using is specified by
properties defined in versions.properties (formerly `starr.number`).

Currently, we're using:

```
scala.binary.version=2.11.0-M4
partest.version.number=1.0-RC3
```

NOTES:
  - The version of Scala being tested must be backwards binary compatible with
    the version of Scala that was used to compile partest.
  - Once 2.11 goes final, `scala.binary.version=2.11`, and `starr.version=2.11.0`.
  - Need scalacheck on classpath for test/partest scalacheck tests.
  - Removed atrophied ant tests (haven't been run/changed for at least two years
    I checked 81d659141a as a "random" sample).
  - Removed scalacheck. It's resolved as a partest dependency.
  - For now, use a locally built scalap
  - Kept the trace macro in the main repo (partest-extras)
  - New targets for faster pr validation: test-core-opt, test-stab-opt
  - Reused partest eclipse/intellij project to partest-extras
    (note: the partest dependency is hard-coded)

4 files changed, 134 insertions, 0 deletions

diff --git a/src/partest-javaagent/scala/tools/partest/javaagent/ASMTransformer.java b/src/partest-javaagent/scala/tools/partest/javaagent/ASMTransformer.java
new file mode 100644
index 0000000000..86f5e64516
--- /dev/null
+++ b/src/partest-javaagent/scala/tools/partest/javaagent/ASMTransformer.java
@@ -0,0 +1,49 @@
+/* NEST (New Scala Test)
+ * Copyright 2007-2013 LAMP/EPFL
+ * @author Grzegorz Kossakowski
+ */
+
+package scala.tools.partest.javaagent;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.security.ProtectionDomain;
+
+import scala.tools.asm.ClassReader;
+import scala.tools.asm.ClassWriter;
+
+public class ASMTransformer implements ClassFileTransformer {
+
+  private boolean shouldTransform(String className) {
+    return
+        // do not instrument instrumentation logic (in order to avoid infinite recursion)
+        !className.startsWith("scala/tools/partest/instrumented/") &&
+        !className.startsWith("scala/tools/partest/javaagent/") &&
+        // we instrument all classes from empty package
+        (!className.contains("/") ||
+        // we instrument all classes from scala package
+        className.startsWith("scala/") ||
+        // we instrument all classes from `instrumented` package
+        className.startsWith("instrumented/"));
+  }
+
+        public byte[] transform(final ClassLoader classLoader, final String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
+          if (shouldTransform(className)) {
+            ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS) {
+              @Override protected String getCommonSuperClass(final String type1, final String type2) {
+                // Since we are not recomputing stack frame map, this should never be called we override this method because
+                // default implementation uses reflection for implementation and might try to load the class that we are
+                // currently processing. That leads to weird results like swallowed exceptions and classes being not
+                // transformed.
+                throw new RuntimeException("Unexpected call to getCommonSuperClass(" + type1 + ", " + type2 +
+                    ") while transforming " + className);
+              }
+            };
+                ProfilerVisitor visitor = new ProfilerVisitor(writer);
+                ClassReader reader = new ClassReader(classfileBuffer);
+                reader.accept(visitor, 0);
+                return writer.toByteArray();
+          } else {
+            return classfileBuffer;
+          }
+        }
+}
diff --git a/src/partest-javaagent/scala/tools/partest/javaagent/MANIFEST.MF b/src/partest-javaagent/scala/tools/partest/javaagent/MANIFEST.MF
new file mode 100644
index 0000000000..be0fee46a2
--- /dev/null
+++ b/src/partest-javaagent/scala/tools/partest/javaagent/MANIFEST.MF
@@ -0,0 +1 @@
+Premain-Class: scala.tools.partest.javaagent.ProfilingAgent
diff --git a/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java b/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java
new file mode 100644
index 0000000000..b1b100fbb0
--- /dev/null
+++ b/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java
@@ -0,0 +1,59 @@
+/* NEST (New Scala Test)
+ * Copyright 2007-2013 LAMP/EPFL
+ * @author Grzegorz Kossakowski
+ */
+
+package scala.tools.partest.javaagent;
+
+import scala.tools.asm.ClassVisitor;
+import scala.tools.asm.MethodVisitor;
+import scala.tools.asm.Opcodes;
+
+public class ProfilerVisitor extends ClassVisitor implements Opcodes {
+
+  private static String profilerClass = "scala/tools/partest/instrumented/Profiler";
+
+  public ProfilerVisitor(final ClassVisitor cv) {
+    super(ASM4, cv);
+  }
+
+  private String className = null;
+
+  @Override
+  public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+    className = name;
+    super.visit(version, access, name, signature, superName, interfaces);
+  }
+
+  public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+    // delegate the method call to the next
+    // chained visitor
+    MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
+    if (!profilerClass.equals(className)) {
+      // only instrument non-abstract methods
+      if((access & ACC_ABSTRACT) == 0) {
+        assert(className != null);
+        /* The following instructions do not modify compressed stack frame map so
+         * we don't need to worry about recalculating stack frame map. Specifically,
+         * let's quote "ASM 4.0, A Java bytecode engineering library" guide (p. 40):
+         *
+         *   In order to save space, a compiled method does not contain one frame per
+         *   instruction: in fact it contains only the frames for the instructions
+         *   that correspond to jump targets or exception handlers, or that follow
+         *   unconditional jump instructions. Indeed the other frames can be easily
+         *   and quickly inferred from these ones.
+         *
+         * Instructions below are just loading constants and calling a method so according
+         * to definition above they do not contribute to compressed stack frame map.
+         */
+        mv.visitLdcInsn(className);
+        mv.visitLdcInsn(name);
+        mv.visitLdcInsn(desc);
+        mv.visitMethodInsn(INVOKESTATIC, profilerClass, "methodCalled",
+            "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+      }
+    }
+    return mv;
+  }
+
+}
diff --git a/src/partest-javaagent/scala/tools/partest/javaagent/ProfilingAgent.java b/src/partest-javaagent/scala/tools/partest/javaagent/ProfilingAgent.java
new file mode 100644
index 0000000000..819a5cc39b
--- /dev/null
+++ b/src/partest-javaagent/scala/tools/partest/javaagent/ProfilingAgent.java
@@ -0,0 +1,25 @@
+/* NEST (New Scala Test)
+ * Copyright 2007-2013 LAMP/EPFL
+ * @author Grzegorz Kossakowski
+ */
+
+package scala.tools.partest.javaagent;
+
+import java.lang.instrument.Instrumentation;
+import java.lang.instrument.UnmodifiableClassException;
+
+/**
+ * Profiling agent that instruments byte-code to insert calls to
+ * {@link scala.tools.partest.instrumented.Profiler#methodCalled(String, String, String)}
+ * by using ASM library for byte-code manipulation.
+ */
+public class ProfilingAgent {
+        public static void premain(String args, Instrumentation inst) throws UnmodifiableClassException {
+          // NOTE: we are adding transformer that won't be applied to classes that are already loaded
+          // This should be ok because premain should be executed before main is executed so Scala library
+          // and the test-case itself won't be loaded yet. We rely here on the fact that ASMTransformer does
+          // not depend on Scala library. In case our assumptions are wrong we can always insert call to
+          // inst.retransformClasses.
+          inst.addTransformer(new ASMTransformer(), false);
+        }
+}