Trust your spell-checker: it's "overridden"

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

@@ -446,22 +446,22 @@ public class FunctionCodegen {
         }
     }
 
-    private static boolean differentMethods(Method method, Method overriden) {
+    private static boolean differentMethods(Method method, Method overridden) {
-        if(!method.getReturnType().equals(overriden.getReturnType()))
+        if(!method.getReturnType().equals(overridden.getReturnType()))
             return true;
         Type[] methodArgumentTypes = method.getArgumentTypes();
-        Type[] overridenArgumentTypes = overriden.getArgumentTypes();
+        Type[] overriddenArgumentTypes = overridden.getArgumentTypes();
-        if(methodArgumentTypes.length != overridenArgumentTypes.length)
+        if(methodArgumentTypes.length != overriddenArgumentTypes.length)
             return true;
         for(int i = 0; i != methodArgumentTypes.length; ++i)
-            if(!methodArgumentTypes[i].equals(overridenArgumentTypes[i]))
+            if(!methodArgumentTypes[i].equals(overriddenArgumentTypes[i]))
                 return true;
         return false;
     }
     
     private static void checkOverride(CodegenContext owner, GenerationState state, ClassBuilder v, Method jvmSignature, FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenFunction) {
         Method method = state.getInjector().getJetTypeMapper().mapSignature(functionDescriptor.getName(), functionDescriptor).getAsmMethod();
-        Method overriden = state.getInjector().getJetTypeMapper().mapSignature(overriddenFunction.getName(), overriddenFunction.getOriginal()).getAsmMethod();
+        Method overridden = state.getInjector().getJetTypeMapper().mapSignature(overriddenFunction.getName(), overriddenFunction.getOriginal()).getAsmMethod();
 
         if(overriddenFunction.getModality() == Modality.ABSTRACT) {
             Set<? extends FunctionDescriptor> overriddenFunctions = overriddenFunction.getOverriddenDescriptors();
@@ -470,17 +470,17 @@ public class FunctionCodegen {
             }
         }
 
-        if(differentMethods(method, overriden)) {
+        if(differentMethods(method, overridden)) {
             int flags = ACC_PUBLIC | ACC_BRIDGE; // TODO.
 
-            final MethodVisitor mv = v.newMethod(null, flags, jvmSignature.getName(), overriden.getDescriptor(), null, null);
+            final MethodVisitor mv = v.newMethod(null, flags, jvmSignature.getName(), overridden.getDescriptor(), null, null);
             if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
                 StubCodegen.generateStubCode(mv);
             }
             else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
                 mv.visitCode();
 
-                Type[] argTypes = overriden.getArgumentTypes();
+                Type[] argTypes = overridden.getArgumentTypes();
                 InstructionAdapter iv = new InstructionAdapter(mv);
                 iv.load(0, JetTypeMapper.TYPE_OBJECT);
                 for (int i = 0, reg = 1; i < argTypes.length; i++) {
@@ -495,11 +495,11 @@ public class FunctionCodegen {
                 }
 
                 iv.invokevirtual(state.getInjector().getJetTypeMapper().mapType(((ClassDescriptor) owner.getContextDescriptor()).getDefaultType(), MapTypeMode.VALUE).getInternalName(), jvmSignature.getName(), jvmSignature.getDescriptor());
-                if(JetTypeMapper.isPrimitive(jvmSignature.getReturnType()) && !JetTypeMapper.isPrimitive(overriden.getReturnType()))
+                if(JetTypeMapper.isPrimitive(jvmSignature.getReturnType()) && !JetTypeMapper.isPrimitive(overridden.getReturnType()))
                     StackValue.valueOf(iv, jvmSignature.getReturnType());
                 if(jvmSignature.getReturnType() == Type.VOID_TYPE)
                     iv.aconst(null);
-                iv.areturn(overriden.getReturnType());
+                iv.areturn(overridden.getReturnType());
                 endVisit(mv, "bridge method", BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
             }
         }

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

@@ -1024,18 +1024,18 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 continue;
             }
 
-            Collection<CallableMemberDescriptor> overridenDeclarations = OverridingUtil.getOverridenDeclarations(callableMemberDescriptor);
+            Collection<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(callableMemberDescriptor);
-            for (CallableMemberDescriptor overridenDeclaration : overridenDeclarations) {
+            for (CallableMemberDescriptor overriddenDeclaration : overriddenDeclarations) {
-                if (overridenDeclaration.getModality() != Modality.ABSTRACT) {
+                if (overriddenDeclaration.getModality() != Modality.ABSTRACT) {
-                    if (!CodegenUtil.isInterface(overridenDeclaration.getContainingDeclaration())) {
+                    if (!CodegenUtil.isInterface(overriddenDeclaration.getContainingDeclaration())) {
                         continue root;
                     }
                 }
             }
             
-            for (CallableMemberDescriptor overridenDeclaration : overridenDeclarations) {
+            for (CallableMemberDescriptor overriddenDeclaration : overriddenDeclarations) {
-                if (overridenDeclaration.getModality() != Modality.ABSTRACT) {
+                if (overriddenDeclaration.getModality() != Modality.ABSTRACT) {
-                    r.add(Pair.create(callableMemberDescriptor, overridenDeclaration));
+                    r.add(Pair.create(callableMemberDescriptor, overriddenDeclaration));
                 }
             }
         }

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

@@ -178,7 +178,7 @@ public class BindingContextUtils {
                 // TODO evil code
                 throw new IllegalStateException(
                         "cannot find declaration: fake descriptor" +
-                                " has more then one overriden descriptor: " + callable);
+                                " has more then one overridden descriptor: " + callable);
             }
 
             return callableDescriptorToDeclaration(context, overriddenDescriptors.iterator().next());
@@ -190,9 +190,9 @@ public class BindingContextUtils {
     private static List<PsiElement> callableDescriptorToDeclarations(@NotNull BindingContext context, @NotNull CallableMemberDescriptor callable) {
         if (callable.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
             List<PsiElement> r = new ArrayList<PsiElement>();
-            Set<? extends CallableMemberDescriptor> overridenDescriptors = callable.getOverriddenDescriptors();
+            Set<? extends CallableMemberDescriptor> overriddenDescriptors = callable.getOverriddenDescriptors();
-            for (CallableMemberDescriptor overriden : overridenDescriptors) {
+            for (CallableMemberDescriptor overridden : overriddenDescriptors) {
-                r.addAll(callableDescriptorToDeclarations(context, overriden));
+                r.addAll(callableDescriptorToDeclarations(context, overridden));
             }
             return r;
         }

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

@@ -305,7 +305,7 @@ public class OverrideResolver {
 
     private static void collectMissingImplementations(CallableMemberDescriptor descriptor, Set<CallableMemberDescriptor> abstractNoImpl, Set<CallableMemberDescriptor> manyImpl) {
         if (!descriptor.getKind().isReal()) {
-            Collection<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverridenDeclarations(descriptor);
+            Collection<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor);
             if (overriddenDeclarations.size() == 0) {
                 throw new IllegalStateException();
             }

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

@@ -244,17 +244,17 @@ public class OverridingUtil {
     }
 
     /**
-     * Get overriden descriptors that are declarations or delegations.
+     * Get overridden descriptors that are declarations or delegations.
      *
      * @see CallableMemberDescriptor.Kind#isReal()
      */
-    public static Collection<CallableMemberDescriptor> getOverridenDeclarations(CallableMemberDescriptor descriptor) {
+    public static Collection<CallableMemberDescriptor> getOverriddenDeclarations(CallableMemberDescriptor descriptor) {
         Map<ClassDescriptor, CallableMemberDescriptor> result = Maps.newHashMap();
-        getOverridenDeclarations(descriptor, result);
+        getOverriddenDeclarations(descriptor, result);
         return result.values();
     }
 
-    private static void getOverridenDeclarations(CallableMemberDescriptor descriptor, Map<ClassDescriptor, CallableMemberDescriptor> r) {
+    private static void getOverriddenDeclarations(CallableMemberDescriptor descriptor, Map<ClassDescriptor, CallableMemberDescriptor> r) {
         if (descriptor.getKind().isReal()) {
             r.put((ClassDescriptor) descriptor.getContainingDeclaration(), descriptor);
         }
@@ -262,8 +262,8 @@ public class OverridingUtil {
             if (descriptor.getOverriddenDescriptors().isEmpty()) {
                 throw new IllegalStateException();
             }
-            for (CallableMemberDescriptor overriden : descriptor.getOverriddenDescriptors()) {
+            for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
-                getOverridenDeclarations(overriden, r);
+                getOverriddenDeclarations(overridden, r);
             }
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java

@@ -265,8 +265,8 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
             dest.add(descriptor);
         }
         else {
-            for (CallableDescriptor overriden : descriptor.getOverriddenDescriptors()) {
+            for (CallableDescriptor overridden : descriptor.getOverriddenDescriptors()) {
-                getAllDescriptorsForValueArgumentsResolving((D) overriden, dest);
+                getAllDescriptorsForValueArgumentsResolving((D) overridden, dest);
             }
         }
     }

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

@@ -327,7 +327,7 @@ public final class StaticContext {
                     NamingScope enclosingScope = getEnclosingScope(descriptor);
                     JsFunction correspondingFunction = JsAstUtils.createFunctionWithEmptyBody(enclosingScope.jsScope());
                     NamingScope newScope = enclosingScope.innerScope(correspondingFunction.getScope());
-                    assert (!scopeToFunction.containsKey(newScope)) : "Scope to function value overriden for " + descriptor;
+                    assert (!scopeToFunction.containsKey(newScope)) : "Scope to function value overridden for " + descriptor;
                     scopeToFunction.put(newScope, correspondingFunction);
                     return newScope;
                 }