Supporting Unit.VALUE, to replace #()

#KT-2358 In Progress

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -3367,7 +3367,7 @@ The "returned" value of try expression with no finally is either the last expres
             throw new UnsupportedOperationException("tuple too large");
         }
         if (entries.size() == 0) {
-            v.visitFieldInsn(GETSTATIC, "jet/Tuple0", "INSTANCE", "Ljet/Tuple0;");
+            v.visitFieldInsn(GETSTATIC, "jet/Tuple0", "VALUE", "Ljet/Tuple0;");
             return StackValue.onStack(JET_TUPLE0_TYPE);
         }
 

compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java

@@ -310,7 +310,7 @@ public abstract class StackValue {
     }
 
     public static void putTuple0Instance(InstructionAdapter v) {
-        v.visitFieldInsn(GETSTATIC, "jet/Tuple0", "INSTANCE", "Ljet/Tuple0;");
+        v.visitFieldInsn(GETSTATIC, "jet/Tuple0", "VALUE", "Ljet/Tuple0;");
     }
 
     protected void putAsBoolean(InstructionAdapter v) {

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java

@@ -148,16 +148,25 @@ public class IntrinsicMethods {
         declareIntrinsicProperty(Name.identifier("CharSequence"), Name.identifier("length"), new StringLength());
         declareIntrinsicProperty(Name.identifier("String"), Name.identifier("length"), new StringLength());
 
+        Name tuple0Name = JetStandardClasses.getTuple(0).getName();
+        intrinsicsMap.registerIntrinsic(
+                getClassObjectFqName(tuple0Name),
+                Name.identifier("VALUE"), -1, new UnitValue());
+
         for (PrimitiveType type : PrimitiveType.NUMBER_TYPES) {
             intrinsicsMap.registerIntrinsic(
-                    JetStandardClasses.STANDARD_CLASSES_FQNAME.child(type.getRangeTypeName()).toUnsafe().child(
-                            getClassObjectName(type.getRangeTypeName())),
+                    getClassObjectFqName(type.getRangeTypeName()),
                     Name.identifier("EMPTY"), -1, new EmptyRange(type));
         }
 
         declareArrayMethods();
     }
 
+    @NotNull
+    private static FqNameUnsafe getClassObjectFqName(@NotNull Name builtinClassName) {
+        return JetStandardClasses.STANDARD_CLASSES_FQNAME.child(builtinClassName).toUnsafe().child(getClassObjectName(builtinClassName));
+    }
+
     private void declareArrayMethods() {
 
         for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnitValue.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.codegen.intrinsics;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.asm4.Type;
+import org.jetbrains.asm4.commons.InstructionAdapter;
+import org.jetbrains.jet.codegen.ExpressionCodegen;
+import org.jetbrains.jet.codegen.StackValue;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.lang.psi.JetExpression;
+
+import java.util.List;
+
+import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.JET_TUPLE0_TYPE;
+
+/**
+ * @author abreslav
+ */
+public class UnitValue implements IntrinsicMethod {
+
+    @Override
+    public StackValue generate(
+            ExpressionCodegen codegen,
+            InstructionAdapter v,
+            @NotNull Type expectedType,
+            @Nullable PsiElement element,
+            @Nullable List<JetExpression> arguments,
+            StackValue receiver,
+            @NotNull GenerationState state
+    ) {
+        v.getstatic(JET_TUPLE0_TYPE.getInternalName(), "VALUE", JET_TUPLE0_TYPE.getDescriptor());
+        return StackValue.onStack(expectedType);
+    }
+}