diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java
index 2377bd45919..8ed2b0d14a5 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java
@@ -29,7 +29,9 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.DeferredType;
+import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 import org.jetbrains.jet.util.lazy.LazyValue;
 
 import java.util.*;
@@ -144,14 +146,39 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         }
         generateDelegatingDescriptors(name, MemberExtractor.EXTRACT_FUNCTIONS, result);
         generateEnumClassObjectMethods(result, name);
+        generateDataClassMethods(result, name);
         generateFakeOverrides(name, fromSupertypes, result, FunctionDescriptor.class);
     }
 
+    private void generateDataClassMethods(@NotNull Collection<FunctionDescriptor> result, @NotNull Name name) {
+        if (!JetStandardLibrary.isData(thisDescriptor)) return;
+
+        ConstructorDescriptor constructor = getPrimaryConstructor();
+        if (constructor == null) return;
+
+        int parameterIndex = 0;
+        for (ValueParameterDescriptor parameter : constructor.getValueParameters()) {
+            if (ErrorUtils.isErrorType(parameter.getType())) continue;
+            Set<VariableDescriptor> properties = getProperties(parameter.getName());
+            if (properties.isEmpty()) continue;
+            assert properties.size() == 1 : "A constructor parameter is resolved to more than one (" + properties.size() + ") property: " + parameter;
+            PropertyDescriptor property = (PropertyDescriptor) properties.iterator().next();
+            if (property == null) continue;
+            ++parameterIndex;
+
+            if (name.equals(Name.identifier(DescriptorResolver.COMPONENT_FUNCTION_NAME_PREFIX + parameterIndex))) {
+                SimpleFunctionDescriptor functionDescriptor =
+                        DescriptorResolver.createComponentFunctionDescriptor(parameterIndex, property,
+                                                                             parameter, thisDescriptor, resolveSession.getTrace());
+                result.add(functionDescriptor);
+                break;
+            }
+        }
+    }
+
     private void generateEnumClassObjectMethods(@NotNull Collection<? super FunctionDescriptor> result, @NotNull Name name) {
         if (!isEnumClassObject()) return;
 
-        ClassDescriptor classDescriptor = (ClassDescriptor) thisDescriptor.getContainingDeclaration();
-
         if (name.equals(DescriptorResolver.VALUES_METHOD_NAME)) {
             SimpleFunctionDescriptor valuesMethod = DescriptorResolver
                     .createEnumClassObjectValuesMethod(thisDescriptor, resolveSession.getTrace());
@@ -245,6 +272,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
             }
         }
     }
+
     @Override
     protected void addExtraDescriptors() {
         for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) {
@@ -261,6 +289,24 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
 
         getFunctions(DescriptorResolver.VALUES_METHOD_NAME);
         getFunctions(DescriptorResolver.VALUE_OF_METHOD_NAME);
+
+        addDataClassMethods();
+    }
+
+    private void addDataClassMethods() {
+        if (!JetStandardLibrary.isData(thisDescriptor)) return;
+
+        ConstructorDescriptor constructor = getPrimaryConstructor();
+        if (constructor == null) return;
+
+        // 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);
+            Set<FunctionDescriptor> functions = getFunctions(componentName);
+            if (functions.isEmpty()) break;
+            n++;
+        }
     }
 
     @Override
diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
index e4273687c8e..41da7cd2d03 100644
--- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
@@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveNamespaceComparing
 @InnerTestClasses({LazyResolveNamespaceComparingTestGenerated.LoadKotlin.class, LazyResolveNamespaceComparingTestGenerated.LoadJava.class, LazyResolveNamespaceComparingTestGenerated.NamespaceComparator.class})
 public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyResolveNamespaceComparingTest {
     @TestMetadata("compiler/testData/loadKotlin")
-    @InnerTestClasses({LoadKotlin.Class.class, LoadKotlin.ClassFun.class, LoadKotlin.ClassObject.class, LoadKotlin.Constructor.class, LoadKotlin.Fun.class, LoadKotlin.Prop.class, LoadKotlin.Type.class, LoadKotlin.Visibility.class})
+    @InnerTestClasses({LoadKotlin.Class.class, LoadKotlin.ClassFun.class, LoadKotlin.ClassObject.class, LoadKotlin.Constructor.class, LoadKotlin.DataClass.class, LoadKotlin.Fun.class, LoadKotlin.Prop.class, LoadKotlin.Type.class, LoadKotlin.Visibility.class})
     public static class LoadKotlin extends AbstractLazyResolveNamespaceComparingTest {
         public void testAllFilesPresentInLoadKotlin() throws Exception {
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveNamespaceComparingTest", new File("compiler/testData/loadKotlin"), "kt", true);
@@ -268,6 +268,49 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
             
         }
         
+        @TestMetadata("compiler/testData/loadKotlin/dataClass")
+        public static class DataClass extends AbstractLazyResolveNamespaceComparingTest {
+            public void testAllFilesPresentInDataClass() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.lang.resolve.lazy.AbstractLazyResolveNamespaceComparingTest", new File("compiler/testData/loadKotlin/dataClass"), "kt", true);
+            }
+            
+            @TestMetadata("MixedComponents.kt")
+            public void testMixedComponents() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/MixedComponents.kt");
+            }
+            
+            @TestMetadata("NoComponents.kt")
+            public void testNoComponents() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/NoComponents.kt");
+            }
+            
+            @TestMetadata("OneVal.kt")
+            public void testOneVal() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/OneVal.kt");
+            }
+            
+            @TestMetadata("OpenDataClass.kt")
+            public void testOpenDataClass() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/OpenDataClass.kt");
+            }
+            
+            @TestMetadata("OpenPropertyFinalComponent.kt")
+            public void testOpenPropertyFinalComponent() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/OpenPropertyFinalComponent.kt");
+            }
+            
+            @TestMetadata("TwoVals.kt")
+            public void testTwoVals() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/TwoVals.kt");
+            }
+            
+            @TestMetadata("TwoVars.kt")
+            public void testTwoVars() throws Exception {
+                doTestSinglePackage("compiler/testData/loadKotlin/dataClass/TwoVars.kt");
+            }
+            
+        }
+        
         @TestMetadata("compiler/testData/loadKotlin/fun")
         @InnerTestClasses({Fun.GenericWithTypeVariables.class, Fun.GenericWithoutTypeVariables.class, Fun.NonGeneric.class})
         public static class Fun extends AbstractLazyResolveNamespaceComparingTest {
@@ -850,6 +893,7 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
             suite.addTestSuite(ClassFun.class);
             suite.addTestSuite(ClassObject.class);
             suite.addTestSuite(Constructor.class);
+            suite.addTestSuite(DataClass.class);
             suite.addTest(Fun.innerSuite());
             suite.addTestSuite(Prop.class);
             suite.addTestSuite(Type.class);