Added some new name and scope generation rules.

translator/src/org/jetbrains/k2js/translate/context/StaticContext.java

@@ -15,6 +15,8 @@ import org.jetbrains.k2js.translate.context.generator.Rule;
 import org.jetbrains.k2js.translate.intrinsic.Intrinsics;
 import org.jetbrains.k2js.translate.utils.AnnotationsUtils;
 
+import java.util.Set;
+
 import static org.jetbrains.k2js.translate.utils.AnnotationsUtils.*;
 import static org.jetbrains.k2js.translate.utils.DescriptorUtils.*;
 
@@ -23,7 +25,7 @@ import static org.jetbrains.k2js.translate.utils.DescriptorUtils.*;
  *         <p/>
  *         Aggregates all the static parts of the context.
  */
-public class StaticContext {
+public final class StaticContext {
 
     public static StaticContext generateStaticContext(@NotNull JetStandardLibrary library,
                                                       @NotNull BindingContext bindingContext) {
@@ -272,6 +274,25 @@ public class StaticContext {
 
                 }
             };
+            Rule<JsName> overridingDescriptorsReferToOriginalName = new Rule<JsName>() {
+                @Override
+                public JsName apply(@NotNull DeclarationDescriptor descriptor) {
+                    //TODO: refactor
+                    if (descriptor instanceof FunctionDescriptor) {
+                        Set<? extends FunctionDescriptor> overriddenDescriptors = ((FunctionDescriptor) descriptor).getOverriddenDescriptors();
+                        if (overriddenDescriptors.isEmpty()) {
+                            return null;
+                        } else {
+                            //assert overriddenDescriptors.size() == 1;
+                            //TODO: for now translator can't deal with multiple inheritance good enough
+                            for (FunctionDescriptor overriddenDescriptor : overriddenDescriptors) {
+                                return getNameForDescriptor(overriddenDescriptor);
+                            }
+                        }
+                    }
+                    return null;
+                }
+            };
             addRule(namesForStandardClasses);
             addRule(aliasOverridesNames);
             addRule(constructorHasTheSameNameAsTheClass);
@@ -281,6 +302,7 @@ public class StaticContext {
             addRule(propertiesCorrespondToSpeciallyTreatedBackingFieldNames);
             addRule(namespacesShouldBeDefinedInRootScope);
             addRule(accessorsHasNamesWithSpecialPrefixes);
+            addRule(overridingDescriptorsReferToOriginalName);
             addRule(memberDeclarationsInsideParentsScope);
         }
     }
@@ -294,6 +316,31 @@ public class StaticContext {
     private final class ScopeGenerator extends Generator<NamingScope> {
 
         public ScopeGenerator() {
+            Rule<NamingScope> generateNewScopesForClassesWithNoAncestors = new Rule<NamingScope>() {
+                @Override
+                public NamingScope apply(@NotNull DeclarationDescriptor descriptor) {
+                    if (!(descriptor instanceof ClassDescriptor)) {
+                        return null;
+                    }
+                    if (getSuperclass((ClassDescriptor) descriptor) == null) {
+                        return getRootScope().innerScope("Scope for class " + descriptor.getName());
+                    }
+                    return null;
+                }
+            };
+            Rule<NamingScope> generateInnerScopesForDerivedClasses = new Rule<NamingScope>() {
+                @Override
+                public NamingScope apply(@NotNull DeclarationDescriptor descriptor) {
+                    if (!(descriptor instanceof ClassDescriptor)) {
+                        return null;
+                    }
+                    ClassDescriptor superclass = getSuperclass((ClassDescriptor) descriptor);
+                    if (superclass == null) {
+                        return null;
+                    }
+                    return getScopeForDescriptor(superclass).innerScope("Scope for class " + descriptor.getName());
+                }
+            };
             Rule<NamingScope> generateNewScopesForNamespaceDescriptors = new Rule<NamingScope>() {
                 @Override
                 public NamingScope apply(@NotNull DeclarationDescriptor descriptor) {
@@ -307,9 +354,11 @@ public class StaticContext {
                 @Override
                 public NamingScope apply(@NotNull DeclarationDescriptor descriptor) {
                     NamingScope enclosingScope = getEnclosingScope(descriptor);
-                    return enclosingScope.innerScope("scope for member " + descriptor.getName());
+                    return enclosingScope.innerScope("Scope for member " + descriptor.getName());
                 }
             };
+            addRule(generateNewScopesForClassesWithNoAncestors);
+            addRule(generateInnerScopesForDerivedClasses);
             addRule(generateNewScopesForNamespaceDescriptors);
             addRule(generateInnerScopesForMembers);
         }

translator/src/org/jetbrains/k2js/translate/declaration/ClassTranslator.java

@@ -16,8 +16,10 @@ import org.jetbrains.k2js.translate.general.Translation;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.jetbrains.k2js.translate.utils.BindingUtils.*;
+import static org.jetbrains.k2js.translate.utils.BindingUtils.getClassDescriptor;
+import static org.jetbrains.k2js.translate.utils.BindingUtils.getPropertyDescriptorForConstructorParameter;
 import static org.jetbrains.k2js.translate.utils.DescriptorUtils.findAncestorClass;
+import static org.jetbrains.k2js.translate.utils.DescriptorUtils.getSuperclassDescriptors;
 import static org.jetbrains.k2js.translate.utils.PsiUtils.getPrimaryConstructorParameters;
 
 /**

translator/src/org/jetbrains/k2js/translate/utils/BindingUtils.java

@@ -12,11 +12,9 @@ import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 
-import static org.jetbrains.k2js.translate.utils.DescriptorUtils.getVariableDescriptorForVariableAsFunction;
+import static org.jetbrains.k2js.translate.utils.DescriptorUtils.*;
-import static org.jetbrains.k2js.translate.utils.DescriptorUtils.isVariableAsFunction;
 
 /**
  * @author Pavel Talanov
@@ -118,28 +116,6 @@ public final class BindingUtils {
         return (JetParameter) result;
     }
 
-    @NotNull
-    public static List<ClassDescriptor> getSuperclassDescriptors(@NotNull ClassDescriptor classDescriptor) {
-        Collection<? extends JetType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
-        List<ClassDescriptor> superClassDescriptors = new ArrayList<ClassDescriptor>();
-        for (JetType type : superclassTypes) {
-            ClassDescriptor result = getClassDescriptorForType(type);
-            if (isNotAny(result)) {
-                superClassDescriptors.add(result);
-            }
-        }
-        return superClassDescriptors;
-    }
-
-    @NotNull
-    private static ClassDescriptor getClassDescriptorForType(@NotNull JetType type) {
-        DeclarationDescriptor superClassDescriptor =
-                type.getConstructor().getDeclarationDescriptor();
-        assert superClassDescriptor instanceof ClassDescriptor
-                : "Superclass descriptor of a type should be of type ClassDescriptor";
-        return (ClassDescriptor) superClassDescriptor;
-    }
-
     public static boolean hasAncestorClass(@NotNull BindingContext context, @NotNull JetClassOrObject classDeclaration) {
         ClassDescriptor classDescriptor = getClassDescriptor(context, classDeclaration);
         List<ClassDescriptor> superclassDescriptors = getSuperclassDescriptors(classDescriptor);
@@ -202,7 +178,7 @@ public final class BindingUtils {
         return referencedDescriptor;
     }
 
-    private static boolean isNotAny(@NotNull DeclarationDescriptor superClassDescriptor) {
+    public static boolean isNotAny(@NotNull DeclarationDescriptor superClassDescriptor) {
         return !superClassDescriptor.equals(JetStandardClasses.getAny());
     }
 

translator/src/org/jetbrains/k2js/translate/utils/ClassSorter.java

@@ -10,7 +10,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static org.jetbrains.k2js.translate.utils.BindingUtils.getSuperclassDescriptors;
+import static org.jetbrains.k2js.translate.utils.DescriptorUtils.getSuperclassDescriptors;
+
 
 //TODO: can optimise using less dumb implementation
 

translator/src/org/jetbrains/k2js/translate/utils/DescriptorUtils.java

@@ -5,6 +5,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions;
 import org.jetbrains.k2js.translate.context.Namer;
 
@@ -13,6 +14,8 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
+import static org.jetbrains.k2js.translate.utils.BindingUtils.isNotAny;
+
 /**
  * @author Pavel Talanov
  */
@@ -41,26 +44,6 @@ public final class DescriptorUtils {
         return (descriptor instanceof ConstructorDescriptor);
     }
 
-    @NotNull
-    public static List<DeclarationDescriptor> getOwnDeclarations(@NotNull ClassDescriptor classDescriptor) {
-        Collection<DeclarationDescriptor> allDescriptors =
-                classDescriptor.getDefaultType().getMemberScope().getAllDescriptors();
-
-        return filterByOwner(classDescriptor, allDescriptors);
-    }
-
-    @NotNull
-    private static List<DeclarationDescriptor> filterByOwner(@NotNull DeclarationDescriptor ownerDescriptor,
-                                                             @NotNull Collection<DeclarationDescriptor> allDescriptors) {
-        List<DeclarationDescriptor> resultingList = new ArrayList<DeclarationDescriptor>();
-        for (DeclarationDescriptor memberDescriptor : allDescriptors) {
-            if (memberDescriptor.getContainingDeclaration() == ownerDescriptor) {
-                resultingList.add(memberDescriptor);
-            }
-        }
-        return resultingList;
-    }
-
     @NotNull
     public static FunctionDescriptor getFunctionByName(@NotNull JetScope scope,
                                                        @NotNull String name) {
@@ -102,6 +85,33 @@ public final class DescriptorUtils {
         return null;
     }
 
+    @NotNull
+    public static List<ClassDescriptor> getSuperclassDescriptors(@NotNull ClassDescriptor classDescriptor) {
+        Collection<? extends JetType> superclassTypes = classDescriptor.getTypeConstructor().getSupertypes();
+        List<ClassDescriptor> superClassDescriptors = new ArrayList<ClassDescriptor>();
+        for (JetType type : superclassTypes) {
+            ClassDescriptor result = getClassDescriptorForType(type);
+            if (isNotAny(result)) {
+                superClassDescriptors.add(result);
+            }
+        }
+        return superClassDescriptors;
+    }
+
+    @Nullable
+    public static ClassDescriptor getSuperclass(@NotNull ClassDescriptor classDescriptor) {
+        return findAncestorClass(getSuperclassDescriptors(classDescriptor));
+    }
+
+    @NotNull
+    public static ClassDescriptor getClassDescriptorForType(@NotNull JetType type) {
+        DeclarationDescriptor superClassDescriptor =
+                type.getConstructor().getDeclarationDescriptor();
+        assert superClassDescriptor instanceof ClassDescriptor
+                : "Superclass descriptor of a type should be of type ClassDescriptor";
+        return (ClassDescriptor) superClassDescriptor;
+    }
+
     @NotNull
     public static VariableDescriptor getVariableDescriptorForVariableAsFunction
             (@NotNull VariableAsFunctionDescriptor descriptor) {