Use '$' instead of '-' in package part class names

Otherwise some tools break (e.g. CheckMethodAdapter in ASM, used in generic
signature writer) because they expect class names to be Java identifiers.

Some tests fixed, some will be fixed in future commits

compiler/tests/org/jetbrains/jet/codegen/InlineTestUtil.java

@@ -21,6 +21,9 @@ import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.OutputFile;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.org.objectweb.asm.*;
 import org.jetbrains.org.objectweb.asm.tree.MethodNode;
 
@@ -96,16 +99,17 @@ public class InlineTestUtil {
                 public MethodVisitor visitMethod(
                         int access, @NotNull String name, @NotNull String desc, String signature, String[] exceptions
                 ) {
+                    FqName classFqName = JvmClassName.byInternalName(className.get()).getFqNameForClassNameWithoutDollars();
+                    if (PackageClassUtils.isPackageClassFqName(classFqName)) {
+                        return super.visitMethod(access, name, desc, signature, exceptions);
+                    }
+
                     return new MethodNode(Opcodes.ASM4, access, name, desc, signature, exceptions) {
                         @Override
                         public void visitMethodInsn(int opcode, @NotNull String owner, String name, @NotNull String desc, boolean itf) {
                             MethodInfo methodCall = new MethodInfo(owner, name, desc);
                             if (inlinedMethods.contains(methodCall)) {
                                 MethodInfo fromCall = new MethodInfo(className.get(), this.name, this.desc);
-                                //skip facades
-                                if (methodCall.owner.startsWith(fromCall.owner + "-")) {
-                                    return;
-                                }
 
                                 //skip delegation to trait impl from child class
                                 if (methodCall.owner.endsWith(JvmAbi.TRAIT_IMPL_SUFFIX) && !fromCall.owner.equals(methodCall.owner)) {

compiler/tests/org/jetbrains/jet/codegen/KotlinSyntheticClassAnnotationTest.java

@@ -44,7 +44,7 @@ public class KotlinSyntheticClassAnnotationTest extends CodegenTestCase {
 
     public void testPackagePart() {
         doTest("fun foo() = 42",
-               "-",
+               "$",
                PACKAGE_PART);
     }
 
@@ -62,25 +62,25 @@ public class KotlinSyntheticClassAnnotationTest extends CodegenTestCase {
 
     public void testSamLambda() {
         doTest("val foo = Thread { }",
-               "$",
+               "$1",
                SAM_LAMBDA);
     }
 
     public void testCallableReferenceWrapper() {
         doTest("val f = String::get",
-               "$",
+               "$1",
                CALLABLE_REFERENCE_WRAPPER);
     }
 
     public void testLocalFunction() {
         doTest("fun foo() { fun bar() {} }",
-               "$",
+               "$1",
                LOCAL_FUNCTION);
     }
 
     public void testAnonymousFunction() {
         doTest("val f = {}",
-               "$",
+               "$1",
                ANONYMOUS_FUNCTION);
     }
 
@@ -104,7 +104,7 @@ public class KotlinSyntheticClassAnnotationTest extends CodegenTestCase {
 
     public void testAnonymousObject() {
         doTest("val o = object {}",
-               "$",
+               "$1",
                ANONYMOUS_OBJECT);
     }
 

compiler/tests/org/jetbrains/jet/codegen/OuterClassGenTest.java

@@ -71,17 +71,17 @@ public class OuterClassGenTest extends CodegenTestCase {
     }
 
     public void testObjectLiteralInPackageClass() throws Exception {
-        OuterClassInfo expectedInfo = new OuterClassInfo("foo/FooPackage-outerClassInfo-", null, null);
+        OuterClassInfo expectedInfo = new OuterClassInfo("foo/FooPackage$outerClassInfo$", null, null);
         doCustomTest("foo.FooPackage$packageObjectLiteral$1", expectedInfo, "outerClassInfo");
     }
 
     public void testLocalClassInTopLevelFunction() throws Exception {
-        OuterClassInfo expectedInfo = new OuterClassInfo("foo/FooPackage-outerClassInfo-", "packageMethod", "(Lfoo/Foo;)V");
+        OuterClassInfo expectedInfo = new OuterClassInfo("foo/FooPackage$outerClassInfo$", "packageMethod", "(Lfoo/Foo;)V");
         doCustomTest("foo.FooPackage$packageMethod$PackageLocalClass", expectedInfo, "outerClassInfo");
     }
 
     public void testLocalObjectInTopLevelFunction() throws Exception {
-        OuterClassInfo expectedInfo = new OuterClassInfo("foo/FooPackage-outerClassInfo-", "packageMethod", "(Lfoo/Foo;)V");
+        OuterClassInfo expectedInfo = new OuterClassInfo("foo/FooPackage$outerClassInfo$", "packageMethod", "(Lfoo/Foo;)V");
         doCustomTest("foo.FooPackage$packageMethod$PackageLocalObject", expectedInfo, "outerClassInfo");
     }