some classes from runtime.jar are not meant to be loaded by JDR

* assert runtime implementations from JetStandard* are not loaded
  by JavaDescriptorResolver
* fix wrong @JetMethod in jet.Iterator
* fix jet.Iterator ns was created
* fix incorrect number of functions and tuples in JetStandardClasses
* added TODO about inconsisten Tuple class

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -360,7 +360,7 @@ public class JavaDescriptorResolver {
         // Not let's take a descriptor of a Java class
         ResolverBinaryClassData classData = classDescriptorCache.get(qualifiedName);
         if (classData == null) {
-            PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName);
+            PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
             if (psiClass == null) {
                 return null;
             }
@@ -944,7 +944,7 @@ public class JavaDescriptorResolver {
                 break lookingForPsi;
             }
 
-            psiClass = psiClassFinder.findPsiClass(fqName);
+            psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
             if (psiClass != null) {
                 trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.CLASS_STATICS);
                 break lookingForPsi;
@@ -983,7 +983,7 @@ public class JavaDescriptorResolver {
 
     @Nullable
     private PsiClass getPsiClassForJavaPackageScope(@NotNull FqName packageFQN) {
-        return psiClassFinder.findPsiClass(packageFQN.child(JvmAbi.PACKAGE_CLASS));
+        return psiClassFinder.findPsiClass(packageFQN.child(JvmAbi.PACKAGE_CLASS), PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
     }
 
     private static class ValueParameterDescriptors {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmStdlibNames.java

@@ -64,6 +64,10 @@ public class JvmStdlibNames {
     
 
     public static final JvmClassName JET_OBJECT = new JvmClassName("jet.JetObject");
+
+
+    public static final JvmClassName ASSERT_INVISIBLE_IN_RESOLVER = new JvmClassName("org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver");
+
     
     private JvmStdlibNames() {
     }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinder.java

@@ -26,8 +26,13 @@ import org.jetbrains.jet.lang.resolve.FqName;
  * @author Stepan Koltsov
  */
 public interface PsiClassFinder {
+    enum RuntimeClassesHandleMode {
+        THROW,
+        IGNORE,
+    }
+
     @Nullable
-    PsiClass findPsiClass(@NotNull FqName fqName);
+    PsiClass findPsiClass(@NotNull FqName fqName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode);
     @Nullable
     PsiPackage findPsiPackage(@NotNull FqName fqName);
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiAnnotation;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPackage;
 import com.intellij.psi.impl.compiled.ClsClassImpl;
@@ -29,11 +30,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder;
 import org.jetbrains.jet.plugin.JetFileType;
-import org.jetbrains.jet.utils.PathUtil;
 
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
-import java.util.Collections;
 
 /**
  * @author Stepan Koltsov
@@ -74,7 +73,7 @@ public class PsiClassFinderForJvm implements PsiClassFinder {
 
     @Override
     @Nullable
-    public PsiClass findPsiClass(@NotNull FqName qualifiedName) {
+    public PsiClass findPsiClass(@NotNull FqName qualifiedName, @NotNull RuntimeClassesHandleMode runtimeClassesHandleMode) {
         PsiClass original = javaFacade.findClass(qualifiedName.getFqName(), javaSearchScope);
         PsiClass altClass = altClassFinder.findClass(qualifiedName);
         PsiClass result = original;
@@ -97,6 +96,26 @@ public class PsiClassFinderForJvm implements PsiClassFinder {
             return null;
         }
 
+        if (result == null) {
+            return null;
+        }
+
+        PsiAnnotation assertInvisibleAnnotation = result.getModifierList().findAnnotation(
+                JvmStdlibNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().getFqName());
+        if (assertInvisibleAnnotation != null) {
+            if (runtimeClassesHandleMode == RuntimeClassesHandleMode.IGNORE) {
+                return null;
+            }
+            else if (runtimeClassesHandleMode == RuntimeClassesHandleMode.THROW) {
+                throw new IllegalStateException(
+                        "classpath is configured incorrectly:" +
+                        " class " + qualifiedName + " from runtime must not be loaded by compiler");
+            }
+            else {
+                throw new IllegalStateException("unknown parameter value: " + runtimeClassesHandleMode);
+            }
+        }
+
         return result;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java

@@ -135,13 +135,13 @@ public class JetStandardClasses {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public static final int TUPLE_COUNT = 22;
+    public static final int MAX_TUPLE_ORDER = 22;
     
     private static final Set<TypeConstructor> TUPLE_CONSTRUCTORS = Sets.newHashSet();
 
-    private static final ClassDescriptor[] TUPLE = new ClassDescriptor[TUPLE_COUNT];
+    private static final ClassDescriptor[] TUPLE = new ClassDescriptor[MAX_TUPLE_ORDER + 1];
     static {
-        for (int i = 0; i < TUPLE_COUNT; i++) {
+        for (int i = 0; i <= MAX_TUPLE_ORDER; i++) {
             List<TypeParameterDescriptor> parameters = new ArrayList<TypeParameterDescriptor>();
             ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
                     STANDARD_CLASSES_NAMESPACE,
@@ -175,16 +175,16 @@ public class JetStandardClasses {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    public static final int FUNCTION_COUNT = 22;
+    public static final int MAX_FUNCTION_ORDER = 22;
 
-    private static final ClassDescriptor[] FUNCTION = new ClassDescriptor[FUNCTION_COUNT];
-    private static final ClassDescriptor[] RECEIVER_FUNCTION = new ClassDescriptor[FUNCTION_COUNT];
+    private static final ClassDescriptor[] FUNCTION = new ClassDescriptor[MAX_FUNCTION_ORDER + 1];
+    private static final ClassDescriptor[] RECEIVER_FUNCTION = new ClassDescriptor[MAX_FUNCTION_ORDER + 1];
 
     private static final Set<TypeConstructor> FUNCTION_TYPE_CONSTRUCTORS = Sets.newHashSet();
     private static final Set<TypeConstructor> RECEIVER_FUNCTION_TYPE_CONSTRUCTORS = Sets.newHashSet();
 
     static {
-        for (int i = 0; i < FUNCTION_COUNT; i++) {
+        for (int i = 0; i <= MAX_FUNCTION_ORDER; i++) {
             ClassDescriptorImpl function = new ClassDescriptorImpl(
                     STANDARD_CLASSES_NAMESPACE,
                     Collections.<AnnotationDescriptor>emptyList(),

compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java

@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeProjection;
@@ -127,7 +128,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
         Project project = getProject();
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(
                 CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), project);
-        return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName));
+        return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.THROW);
     }
 
     @NotNull

js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/Intrinsics.java

@@ -110,7 +110,7 @@ public final class Intrinsics {
     }
 
     private void declareTuplesIntrinsics() {
-        for (int tupleSize = 0; tupleSize < JetStandardClasses.TUPLE_COUNT; ++tupleSize) {
+        for (int tupleSize = 0; tupleSize <= JetStandardClasses.MAX_TUPLE_ORDER; ++tupleSize) {
             declareTupleIntrinsics(tupleSize);
         }
     }

runtime/src/jet/BooleanIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface BooleanIterable extends Iterable<Boolean> {
     @Override
     BooleanIterator iterator();

runtime/src/jet/BooleanIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class BooleanIterator implements Iterator<Boolean> {
     public final Boolean next() {
         return nextBoolean();

runtime/src/jet/ByteIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface ByteIterable extends Iterable<Byte> {
     @Override
     ByteIterator iterator();

runtime/src/jet/ByteIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class ByteIterator implements Iterator<Byte> {
     public final Byte next() {
         return nextByte();

runtime/src/jet/ByteRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class ByteRange implements Range<Byte>, ByteIterable {
     private final byte start;
     private final int count;

runtime/src/jet/CharIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface CharIterable extends Iterable<Character> {
     @Override
     CharIterator iterator();

runtime/src/jet/CharIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class CharIterator implements Iterator<Character> {
     public final Character next() {
         return nextChar();

runtime/src/jet/CharRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class CharRange implements Range<Character>, CharIterable {
     private final char start;
     private final int count;

runtime/src/jet/DoubleIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface DoubleIterable extends Iterable<Double> {
     @Override
     DoubleIterator iterator();

runtime/src/jet/DoubleIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class DoubleIterator implements Iterator<Double> {
     public final Double next() {
         return nextDouble();

runtime/src/jet/DoubleRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class DoubleRange implements Range<Double> {
     private final double start;
     private final double size;

runtime/src/jet/ExtensionFunction0.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract  class ExtensionFunction0<E, R>  extends DefaultJetObject {
     protected ExtensionFunction0() {
         super();

runtime/src/jet/ExtensionFunction1.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction1<E, D1, R> extends DefaultJetObject {
     protected ExtensionFunction1() {
         super();

runtime/src/jet/ExtensionFunction10.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction10<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, R> extends DefaultJetObject {
     protected ExtensionFunction10() {
         super();

runtime/src/jet/ExtensionFunction11.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction11<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, R> extends DefaultJetObject {
     protected ExtensionFunction11() {
         super();

runtime/src/jet/ExtensionFunction12.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction12<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, R> extends DefaultJetObject {
     protected ExtensionFunction12() {
         super();

runtime/src/jet/ExtensionFunction13.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction13<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, R> extends DefaultJetObject {
     protected ExtensionFunction13() {
         super();

runtime/src/jet/ExtensionFunction14.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction14<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, R> extends DefaultJetObject {
     protected ExtensionFunction14() {
         super();

runtime/src/jet/ExtensionFunction15.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction15<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, R> extends DefaultJetObject {
     protected ExtensionFunction15() {
         super();

runtime/src/jet/ExtensionFunction16.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction16<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, R> extends DefaultJetObject {
     protected ExtensionFunction16() {
         super();

runtime/src/jet/ExtensionFunction17.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction17<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, R> extends DefaultJetObject {
     protected ExtensionFunction17() {
         super();

runtime/src/jet/ExtensionFunction18.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction18<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, R> extends DefaultJetObject {
     protected ExtensionFunction18() {
         super();

runtime/src/jet/ExtensionFunction19.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction19<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, R> extends DefaultJetObject {
     protected ExtensionFunction19() {
         super();

runtime/src/jet/ExtensionFunction2.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction2<E, D1, D2, R> extends DefaultJetObject {
     protected ExtensionFunction2() {
         super();

runtime/src/jet/ExtensionFunction20.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction20<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, R> extends DefaultJetObject {
     protected ExtensionFunction20() {
         super();

runtime/src/jet/ExtensionFunction21.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction21<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, D21, R> extends DefaultJetObject {
     protected ExtensionFunction21() {
         super();

runtime/src/jet/ExtensionFunction22.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction22<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, D21, D22, R> extends DefaultJetObject {
     protected ExtensionFunction22() {
         super();

runtime/src/jet/ExtensionFunction3.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction3<E, D1, D2, D3, R> extends DefaultJetObject {
     protected ExtensionFunction3() {
         super();

runtime/src/jet/ExtensionFunction4.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction4<E, D1, D2, D3, D4, R> extends DefaultJetObject {
     protected ExtensionFunction4() {
         super();

runtime/src/jet/ExtensionFunction5.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction5<E, D1, D2, D3, D4, D5, R> extends DefaultJetObject {
     protected ExtensionFunction5() {
         super();

runtime/src/jet/ExtensionFunction6.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction6<E, D1, D2, D3, D4, D5, D6, R> extends DefaultJetObject {
     protected ExtensionFunction6() {
         super();

runtime/src/jet/ExtensionFunction7.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction7<E, D1, D2, D3, D4, D5, D6, D7, R> extends DefaultJetObject {
     protected ExtensionFunction7() {
         super();

runtime/src/jet/ExtensionFunction8.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction8<E, D1, D2, D3, D4, D5, D6, D7, D8, R> extends DefaultJetObject {
     protected ExtensionFunction8() {
         super();

runtime/src/jet/ExtensionFunction9.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class ExtensionFunction9<E, D1, D2, D3, D4, D5, D6, D7, D8, D9, R> extends DefaultJetObject {
     protected ExtensionFunction9() {
         super();

runtime/src/jet/FloatIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface FloatIterable extends Iterable<Float> {
     @Override
     FloatIterator iterator();

runtime/src/jet/FloatIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class FloatIterator implements Iterator<Float> {
     public final Float next() {
         return nextFloat();

runtime/src/jet/FloatRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class FloatRange implements Range<Float> {
     private final float start;
     private final float size;

runtime/src/jet/Function0.java

@@ -19,7 +19,10 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /** A function with no arguments */
+@AssertInvisibleInResolver
 public abstract class Function0<R> extends DefaultJetObject {
     public abstract R invoke();
 

runtime/src/jet/Function1.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function1<D1, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1);
 

runtime/src/jet/Function10.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function10<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10);
 

runtime/src/jet/Function11.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function11<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11);
 

runtime/src/jet/Function12.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function12<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12);
 

runtime/src/jet/Function13.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function13<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13);
 

runtime/src/jet/Function14.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function14<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14);
 

runtime/src/jet/Function15.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function15<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15);
 

runtime/src/jet/Function16.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function16<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16);
 

runtime/src/jet/Function17.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function17<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17);
 

runtime/src/jet/Function18.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function18<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18);
 

runtime/src/jet/Function19.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function19<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19);
 

runtime/src/jet/Function2.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function2<D1, D2, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2);
 

runtime/src/jet/Function20.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function20<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20);
 

runtime/src/jet/Function21.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function21<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, D21, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20, D21 d21);
 

runtime/src/jet/Function22.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function22<D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16, D17, D18, D19, D20, D21, D22, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20, D21 d21, D22 d22);
 

runtime/src/jet/Function3.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function3<D1, D2, D3, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3);
 

runtime/src/jet/Function4.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function4<D1, D2, D3, D4, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4);
 

runtime/src/jet/Function5.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function5<D1, D2, D3, D4, D5, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5);
 

runtime/src/jet/Function6.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function6<D1, D2, D3, D4, D5, D6, R> extends DefaultJetObject {
 
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6);

runtime/src/jet/Function7.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function7<D1, D2, D3, D4, D5, D6, D7, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7);
 

runtime/src/jet/Function8.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function8<D1, D2, D3, D4, D5, D6, D7, D8, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8);
 

runtime/src/jet/Function9.java

@@ -19,6 +19,9 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public abstract class Function9<D1, D2, D3, D4, D5, D6, D7, D8, D9, R> extends DefaultJetObject {
     public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9);
 

runtime/src/jet/IntIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface IntIterable extends Iterable<Integer> {
     @Override
     IntIterator iterator();

runtime/src/jet/IntIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class IntIterator implements Iterator<Integer> {
     public final Integer next() {
         return nextInt();

runtime/src/jet/IntRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class IntRange implements Range<Integer>, IntIterable {
     private final int start;
     private final int count;

runtime/src/jet/Iterable.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public interface Iterable<T> {
     Iterator<T> iterator ();
 }

runtime/src/jet/Iterator.java

@@ -17,9 +17,10 @@
 package jet;
 
 import jet.runtime.typeinfo.JetMethod;
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
 
+@AssertInvisibleInResolver
 public interface Iterator<T> {
-    @JetMethod(kind = JetMethod.KIND_PROPERTY)
     boolean getHasNext();
     T next ();
 }

runtime/src/jet/LongIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface LongIterable extends Iterable<Long> {
     @Override
     LongIterator iterator();

runtime/src/jet/LongIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class LongIterator implements Iterator<Long> {
     public final Long next() {
         return nextLong();

runtime/src/jet/LongRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class LongRange implements Range<Long>, LongIterable {
     private final long start;
     private final long count;

runtime/src/jet/Range.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public interface Range<T extends Comparable<T>> {
     boolean contains(T item);
 }

runtime/src/jet/ShortIterable.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public interface ShortIterable extends Iterable<Short> {
     @Override
     ShortIterator iterator();

runtime/src/jet/ShortIterator.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public abstract class ShortIterator implements Iterator<Short> {
     public final Short next() {
         return nextShort();

runtime/src/jet/ShortRange.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public final class ShortRange implements Range<Short>, ShortIterable {
     private final short start;
     private final int count;

runtime/src/jet/Tuple.java

@@ -15,9 +15,12 @@
  */
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * Represents the common interface of a tuple
  */
+// @AssertInvisibleInResolver // TODO TupleN classes has no Tuple superclass
 public abstract class Tuple extends DefaultJetObject {
 
     /**

runtime/src/jet/Tuple0.java

@@ -16,9 +16,12 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
 /**
  * @author alex.tkachman
  */
+@AssertInvisibleInResolver
 public class Tuple0 extends Tuple {
     public static final Tuple0 INSTANCE = new Tuple0();
 

runtime/src/jet/Tuple1.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple1<T1> extends Tuple {
     public final T1 _1;
 

runtime/src/jet/Tuple10.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple11.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple12.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple13.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple14.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple15.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple16.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple17.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple18.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple19.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple2.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple2<T1, T2> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple20.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple21.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple22.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple3.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple3<T1, T2, T3> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple4.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple4<T1, T2, T3, T4> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple5.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple5<T1, T2, T3, T4, T5> extends Tuple {
     public final T1 _1;
     public final T2 _2;

runtime/src/jet/Tuple6.java

@@ -16,6 +16,9 @@
 
 package jet;
 
+import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver;
+
+@AssertInvisibleInResolver
 public class Tuple6<T1, T2, T3, T4, T5, T6> extends Tuple {
     public final T1 _1;
     public final T2 _2;