From 83de1581caff741ee01ddd0448e1fdcfa09c730e Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 27 Apr 2012 10:47:28 +0400 Subject: [PATCH] Trust your spell-checker: it's "overridden" --- .../jet/codegen/FunctionCodegen.java | 22 +++++++++---------- .../codegen/ImplementationBodyCodegen.java | 14 ++++++------ .../jet/lang/resolve/BindingContextUtils.java | 8 +++---- .../jet/lang/resolve/OverrideResolver.java | 2 +- .../jet/lang/resolve/OverridingUtil.java | 12 +++++----- .../ValueArgumentsToParametersMapper.java | 4 ++-- .../k2js/translate/context/StaticContext.java | 2 +- 7 files changed, 32 insertions(+), 32 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 0a828995516..abc28ddd3d9 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -446,22 +446,22 @@ public class FunctionCodegen { } } - private static boolean differentMethods(Method method, Method overriden) { - if(!method.getReturnType().equals(overriden.getReturnType())) + private static boolean differentMethods(Method method, Method overridden) { + if(!method.getReturnType().equals(overridden.getReturnType())) return true; Type[] methodArgumentTypes = method.getArgumentTypes(); - Type[] overridenArgumentTypes = overriden.getArgumentTypes(); - if(methodArgumentTypes.length != overridenArgumentTypes.length) + Type[] overriddenArgumentTypes = overridden.getArgumentTypes(); + 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 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)); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 7a7b2cd023d..187277785a0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -1024,18 +1024,18 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { continue; } - Collection overridenDeclarations = OverridingUtil.getOverridenDeclarations(callableMemberDescriptor); - for (CallableMemberDescriptor overridenDeclaration : overridenDeclarations) { - if (overridenDeclaration.getModality() != Modality.ABSTRACT) { - if (!CodegenUtil.isInterface(overridenDeclaration.getContainingDeclaration())) { + Collection overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(callableMemberDescriptor); + for (CallableMemberDescriptor overriddenDeclaration : overriddenDeclarations) { + if (overriddenDeclaration.getModality() != Modality.ABSTRACT) { + if (!CodegenUtil.isInterface(overriddenDeclaration.getContainingDeclaration())) { continue root; } } } - for (CallableMemberDescriptor overridenDeclaration : overridenDeclarations) { - if (overridenDeclaration.getModality() != Modality.ABSTRACT) { - r.add(Pair.create(callableMemberDescriptor, overridenDeclaration)); + for (CallableMemberDescriptor overriddenDeclaration : overriddenDeclarations) { + if (overriddenDeclaration.getModality() != Modality.ABSTRACT) { + r.add(Pair.create(callableMemberDescriptor, overriddenDeclaration)); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java index e33be6780f7..b9479f4766a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java +++ b/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 callableDescriptorToDeclarations(@NotNull BindingContext context, @NotNull CallableMemberDescriptor callable) { if (callable.getKind() != CallableMemberDescriptor.Kind.DECLARATION) { List r = new ArrayList(); - Set overridenDescriptors = callable.getOverriddenDescriptors(); - for (CallableMemberDescriptor overriden : overridenDescriptors) { - r.addAll(callableDescriptorToDeclarations(context, overriden)); + Set overriddenDescriptors = callable.getOverriddenDescriptors(); + for (CallableMemberDescriptor overridden : overriddenDescriptors) { + r.addAll(callableDescriptorToDeclarations(context, overridden)); } return r; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 065764e8a4b..b2526dda5f7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -305,7 +305,7 @@ public class OverrideResolver { private static void collectMissingImplementations(CallableMemberDescriptor descriptor, Set abstractNoImpl, Set manyImpl) { if (!descriptor.getKind().isReal()) { - Collection overriddenDeclarations = OverridingUtil.getOverridenDeclarations(descriptor); + Collection overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor); if (overriddenDeclarations.size() == 0) { throw new IllegalStateException(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java index d2a9429311e..8c7fe2bbe18 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java +++ b/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 getOverridenDeclarations(CallableMemberDescriptor descriptor) { + public static Collection getOverriddenDeclarations(CallableMemberDescriptor descriptor) { Map result = Maps.newHashMap(); - getOverridenDeclarations(descriptor, result); + getOverriddenDeclarations(descriptor, result); return result.values(); } - private static void getOverridenDeclarations(CallableMemberDescriptor descriptor, Map r) { + private static void getOverriddenDeclarations(CallableMemberDescriptor descriptor, Map 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()) { - getOverridenDeclarations(overriden, r); + for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) { + getOverriddenDeclarations(overridden, r); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java index 6fd1de795c0..138183a1b8f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java +++ b/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()) { - getAllDescriptorsForValueArgumentsResolving((D) overriden, dest); + for (CallableDescriptor overridden : descriptor.getOverriddenDescriptors()) { + getAllDescriptorsForValueArgumentsResolving((D) overridden, dest); } } } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java index 2f20842f287..36a5b0d3301 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java +++ b/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; }