Refactoring: create DataClassUtils and move all "component" function utils there

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DataClassUtils.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2014 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.lang.resolve.dataClassUtils
+
+import org.jetbrains.jet.lang.resolve.name.Name
+import java.util.regex.Pattern
+
+private val COMPONENT_FUNCTION_NAME_PREFIX = "component"
+
+public fun isComponentLike(name: Name): Boolean {
+    if (!name.asString().startsWith(COMPONENT_FUNCTION_NAME_PREFIX)) return false
+
+    try {
+        getComponentIndex(name)
+    }
+    catch (e: NumberFormatException) {
+        return false
+    }
+
+    return true
+}
+
+public fun getComponentIndex(componentName: Name): Int =
+    componentName.asString().substring(COMPONENT_FUNCTION_NAME_PREFIX.length).toInt()
+
+public fun createComponentName(index: Int): Name =
+    Name.identifier(COMPONENT_FUNCTION_NAME_PREFIX + index)

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

@@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.jet.lang.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -63,7 +64,6 @@ import static org.jetbrains.jet.lexer.JetTokens.VARARG_KEYWORD;
 
 public class DescriptorResolver {
     public static final Name COPY_METHOD_NAME = Name.identifier("copy");
-    public static final String COMPONENT_FUNCTION_NAME_PREFIX = "component";
     private static final Set<JetModifierKeywordToken> MODIFIERS_ILLEGAL_ON_PARAMETERS;
     static {
         MODIFIERS_ILLEGAL_ON_PARAMETERS = Sets.newHashSet();
@@ -382,13 +382,13 @@ public class DescriptorResolver {
             @NotNull ClassDescriptor classDescriptor,
             @NotNull BindingTrace trace
     ) {
-        String functionName = COMPONENT_FUNCTION_NAME_PREFIX + parameterIndex;
+        Name functionName = DataClassUtilsPackage.createComponentName(parameterIndex);
         JetType returnType = property.getType();
 
         SimpleFunctionDescriptorImpl functionDescriptor = SimpleFunctionDescriptorImpl.create(
                 classDescriptor,
                 Annotations.EMPTY,
-                Name.identifier(functionName),
+                functionName,
                 CallableMemberDescriptor.Kind.SYNTHESIZED,
                 parameter.getSource()
         );

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

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
+import org.jetbrains.jet.lang.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
@@ -598,8 +599,7 @@ public class OverrideResolver {
 
     private void checkOverrideForMember(@NotNull final CallableMemberDescriptor declared) {
         if (declared.getKind() == CallableMemberDescriptor.Kind.SYNTHESIZED) {
-            // TODO: this should be replaced soon by a framework of synthesized member generation tools
-            if (declared.getName().asString().startsWith(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX)) {
+            if (DataClassUtilsPackage.isComponentLike(declared.getName())) {
                 checkOverrideForComponentFunction(declared);
             }
             return;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.ClassMemberDeclarationProvider;
@@ -174,10 +175,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
 
             ++componentIndex;
 
-            if (name.equals(Name.identifier(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX + componentIndex))) {
-                SimpleFunctionDescriptor functionDescriptor =
-                        DescriptorResolver.createComponentFunctionDescriptor(componentIndex, property,
-                                                                             parameter, thisDescriptor, trace);
+            if (name.equals(DataClassUtilsPackage.createComponentName(componentIndex))) {
+                SimpleFunctionDescriptor functionDescriptor = DescriptorResolver.createComponentFunctionDescriptor(
+                        componentIndex, property, parameter, thisDescriptor, trace);
                 result.add(functionDescriptor);
                 break;
             }
@@ -316,7 +316,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         // Generate componentN functions until there's no such function for some n
         int n = 1;
         while (true) {
-            Name componentName = Name.identifier(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX + n);
+            Name componentName = DataClassUtilsPackage.createComponentName(n);
             Set<FunctionDescriptor> functions = getFunctions(componentName);
             if (functions.isEmpty()) break;
 

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java

@@ -43,6 +43,7 @@ import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintsUtil;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
+import org.jetbrains.jet.lang.resolve.dataClassUtils.DataClassUtilsPackage;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -336,7 +337,7 @@ public class ExpressionTypingUtils {
     ) {
         int componentIndex = 1;
         for (JetMultiDeclarationEntry entry : multiDeclaration.getEntries()) {
-            Name componentName = Name.identifier(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX + componentIndex);
+            Name componentName = DataClassUtilsPackage.createComponentName(componentIndex);
             componentIndex++;
 
             JetType expectedType = getExpectedTypeForComponent(context, entry);