Add tests about resolving __class__ (incl. implicit) and __doc__

python/psi-api/src/com/jetbrains/python/PyNames.java

@@ -165,6 +165,7 @@ public class PyNames {
   public static final String DIV = "__div__";
   public static final String TRUEDIV = "__truediv__";
   public static final String AITER = "__aiter__";
+  public static final String SIZEOF = "__sizeof__";
 
   public static final String NAME = "__name__";
   public static final String ENTER = "__enter__";

python/testData/inspections/PyUnresolvedReferencesInspection/dunderClass.py

@@ -0,0 +1,3 @@
+class A:
+    def foo(self):
+        return <error descr="Unresolved reference '__class__'">__class__</error>

python/testData/inspections/PyUnresolvedReferencesInspection3K/dunderClass.py

@@ -0,0 +1,3 @@
+class A:
+    def foo(self):
+        return __class__

python/testData/resolve/ClassAttrInDeclaration.py

@@ -0,0 +1,4 @@
+class A:
+    my_attr = 17
+    print(my_attr)
+#           <ref>

python/testData/resolve/ClassAttrInDeclarationNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    my_attr = 17
+    print(my_attr)
+#           <ref>

python/testData/resolve/DunderClassInDeclaration.py

@@ -0,0 +1,3 @@
+class A:
+    print(__class__)
+#           <ref>

python/testData/resolve/DunderClassInDeclarationInsideFunction.py

@@ -0,0 +1,6 @@
+def foo():
+    class A:
+        print(__class__)
+    #           <ref>
+
+    return A()

python/testData/resolve/DunderClassInDeclarationNewStyleClass.py

@@ -0,0 +1,3 @@
+class A(object):
+    print(__class__)
+#           <ref>

python/testData/resolve/DunderClassInDeclarationWithClassAttr.py

@@ -0,0 +1,4 @@
+class A:
+    __class__ = 17
+    print(__class__)
+#           <ref>

python/testData/resolve/DunderClassInDeclarationWithClassAttrNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    __class__ = 17
+    print(__class__)
+#           <ref>

python/testData/resolve/DunderClassInDeclarationWithInheritedClassAttr.py

@@ -0,0 +1,6 @@
+class A(object):
+    __class__ = 17
+
+class B(A):
+    print(__class__)
+#           <ref>

python/testData/resolve/DunderDocInDeclaration.py

@@ -0,0 +1,3 @@
+class A:
+    print(__doc__)
+#           <ref>

python/testData/resolve/DunderDocInDeclarationNewStyleClass.py

@@ -0,0 +1,3 @@
+class A(object):
+    print(__doc__)
+#           <ref>

python/testData/resolve/DunderDocInDeclarationWithClassAttr.py

@@ -0,0 +1,4 @@
+class A:
+    __doc__ = 17
+    print(__doc__)
+#           <ref>

python/testData/resolve/DunderDocInDeclarationWithClassAttrNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    __doc__ = 17
+    print(__doc__)
+#           <ref>

python/testData/resolve/DunderDocInDeclarationWithInheritedClassAttr.py

@@ -0,0 +1,6 @@
+class A(object):
+    __doc__ = 17
+
+class B(A):
+    print(__doc__)
+#           <ref>

python/testData/resolve/DunderSizeOfInDeclaration.py

@@ -0,0 +1,3 @@
+class A:
+    print(__sizeof__)
+#           <ref>

python/testData/resolve/DunderSizeOfInDeclarationNewStyleClass.py

@@ -0,0 +1,3 @@
+class A(object):
+    print(__sizeof__)
+#           <ref>

python/testData/resolve/DunderSizeOfInDeclarationWithClassAttr.py

@@ -0,0 +1,4 @@
+class A:
+    __sizeof__ = 17
+    print(__sizeof__)
+#           <ref>

python/testData/resolve/DunderSizeOfInDeclarationWithClassAttrNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    __sizeof__ = 17
+    print(__sizeof__)
+#           <ref>

python/testData/resolve/DunderSizeOfInDeclarationWithInheritedClassAttr.py

@@ -0,0 +1,6 @@
+class A(object):
+    __sizeof__ = 17
+
+class B(A):
+    print(__sizeof__)
+#           <ref>

python/testData/resolve/ImplicitClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    my_attr = 15
+
+    def foo(self):
+        return my_attr
+#                <ref>

python/testData/resolve/ImplicitClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    my_attr = 15
+
+    def foo(self):
+        return my_attr
+#                <ref>

python/testData/resolve/ImplicitDunderClass.py

@@ -0,0 +1,4 @@
+class A:
+    def foo(self):
+        return __class__
+#                <ref>

python/testData/resolve/ImplicitDunderClassNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    def foo(self):
+        return __class__
+#                <ref>

python/testData/resolve/ImplicitDunderClassWithClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    __class__ = 15
+
+    def foo(self):
+        return __class__
+#                <ref>

python/testData/resolve/ImplicitDunderClassWithClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    __class__ = 15
+
+    def foo(self):
+        return __class__
+#                <ref>

python/testData/resolve/ImplicitDunderClassWithInheritedClassAttr.py

@@ -0,0 +1,7 @@
+class A(object):
+    __class__ = int
+
+class B(A):
+    def foo(self):
+        return __class__
+#                <ref>

python/testData/resolve/ImplicitDunderDoc.py

@@ -0,0 +1,4 @@
+class A:
+    def foo(self):
+        return __doc__
+#                <ref>

python/testData/resolve/ImplicitDunderDocNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    def foo(self):
+        return __doc__
+#                <ref>

python/testData/resolve/ImplicitDunderDocWithClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    __doc__ = 15
+
+    def foo(self):
+        return __doc__
+#                <ref>

python/testData/resolve/ImplicitDunderDocWithClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    __doc__ = 15
+
+    def foo(self):
+        return __doc__
+#                <ref>

python/testData/resolve/ImplicitDunderDocWithInheritedClassAttr.py

@@ -0,0 +1,7 @@
+class A(object):
+    __doc__ = "abc"
+
+class B(A):
+    def foo(self):
+        return __doc__
+#                <ref>

python/testData/resolve/ImplicitDunderSizeOf.py

@@ -0,0 +1,4 @@
+class A:
+    def foo(self):
+        return __sizeof__
+#                <ref>

python/testData/resolve/ImplicitDunderSizeOfNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    def foo(self):
+        return __sizeof__
+#                <ref>

python/testData/resolve/ImplicitDunderSizeOfWithClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    __sizeof__ = 15
+
+    def foo(self):
+        return __sizeof__
+#                <ref>

python/testData/resolve/ImplicitDunderSizeOfWithClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    __sizeof__ = 15
+
+    def foo(self):
+        return __sizeof__
+#                <ref>

python/testData/resolve/ImplicitDunderSizeOfWithInheritedClassAttr.py

@@ -0,0 +1,7 @@
+class A(object):
+    __sizeof__ = 4
+
+class B(A):
+    def foo(self):
+        return __sizeof__
+#                <ref>

python/testData/resolve/ImplicitInheritedClassAttr.py

@@ -0,0 +1,7 @@
+class A(object):
+    my_attr = 4
+
+class B(A):
+    def foo(self):
+        return my_attr
+#                <ref>

python/testData/resolve/ImplicitUndeclaredClassAttr.py

@@ -0,0 +1,4 @@
+class A:
+    def foo(self):
+        return my_attr
+#                <ref>

python/testData/resolve/ImplicitUndeclaredClassAttrNewStyleClass.py

@@ -0,0 +1,4 @@
+class A(object):
+    def foo(self):
+        return my_attr
+#                <ref>

python/testData/resolve/InheritedClassAttrInDeclaration.py

@@ -0,0 +1,6 @@
+class A(object):
+    my_attr = 17
+
+class B(A):
+    print(my_attr)
+#           <ref>

python/testData/resolve/InstanceClassAttr.py

@@ -0,0 +1,7 @@
+class A:
+    my_attr = 15
+
+
+a = A()
+print(a.my_attr)
+#         <ref>

python/testData/resolve/InstanceClassAttrNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    my_attr = 15
+
+
+a = A()
+print(a.my_attr)
+#         <ref>

python/testData/resolve/InstanceDunderClass.py

@@ -0,0 +1,7 @@
+class A:
+    pass
+
+
+a = A()
+print(a.__class__)
+#         <ref>

python/testData/resolve/InstanceDunderClassNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    pass
+
+
+a = A()
+print(a.__class__)
+#         <ref>

python/testData/resolve/InstanceDunderClassWithClassAttr.py

@@ -0,0 +1,7 @@
+class A:
+    __class__ = 15
+
+
+a = A()
+print(a.__class__)
+#         <ref>

python/testData/resolve/InstanceDunderClassWithClassAttrNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    __class__ = 15
+
+
+a = A()
+print(a.__class__)
+#         <ref>

python/testData/resolve/InstanceDunderClassWithInheritedClassAttr.py

@@ -0,0 +1,10 @@
+class A(object):
+    __class__ = 15
+
+class B(A):
+    pass
+
+
+b = B()
+print(b.__class__)
+#         <ref>

python/testData/resolve/InstanceDunderDoc.py

@@ -0,0 +1,7 @@
+class A:
+    pass
+
+
+a = A()
+print(a.__doc__)
+#         <ref>

python/testData/resolve/InstanceDunderDocNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    pass
+
+
+a = A()
+print(a.__doc__)
+#         <ref>

python/testData/resolve/InstanceDunderDocWithClassAttr.py

@@ -0,0 +1,7 @@
+class A:
+    __doc__ = 15
+
+
+a = A()
+print(a.__doc__)
+#         <ref>

python/testData/resolve/InstanceDunderDocWithClassAttrNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    __doc__ = 15
+
+
+a = A()
+print(a.__doc__)
+#         <ref>

python/testData/resolve/InstanceDunderDocWithInheritedClassAttr.py

@@ -0,0 +1,10 @@
+class A(object):
+    __doc__ = 16
+
+class B(A):
+    pass
+
+
+b = B()
+print(b.__doc__)
+#         <ref>

python/testData/resolve/InstanceDunderSizeOf.py

@@ -0,0 +1,7 @@
+class A:
+    pass
+
+
+a = A()
+print(a.__sizeof__)
+#         <ref>

python/testData/resolve/InstanceDunderSizeOfNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    pass
+
+
+a = A()
+print(a.__sizeof__)
+#         <ref>

python/testData/resolve/InstanceDunderSizeOfWithClassAttr.py

@@ -0,0 +1,7 @@
+class A:
+    __sizeof__ = 15
+
+
+a = A()
+print(a.__sizeof__)
+#         <ref>

python/testData/resolve/InstanceDunderSizeOfWithClassAttrNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    __sizeof__ = 15
+
+
+a = A()
+print(a.__sizeof__)
+#         <ref>

python/testData/resolve/InstanceDunderSizeOfWithInheritedClassAttr.py

@@ -0,0 +1,10 @@
+class A(object):
+    __sizeof__ = 17
+
+class B(A):
+    pass
+
+
+b = B()
+print(b.__sizeof__)
+#         <ref>

python/testData/resolve/InstanceInheritedClassAttr.py

@@ -0,0 +1,10 @@
+class A(object):
+    my_attr = 17
+
+class B(A):
+    pass
+
+
+b = B()
+print(b.my_attr)
+#         <ref>

python/testData/resolve/InstanceUndeclaredClassAttr.py

@@ -0,0 +1,7 @@
+class A:
+    pass
+
+
+a = A()
+print(a.my_attr)
+#         <ref>

python/testData/resolve/InstanceUndeclaredClassAttrNewStyleClass.py

@@ -0,0 +1,7 @@
+class A(object):
+    pass
+
+
+a = A()
+print(a.my_attr)
+#         <ref>

python/testData/resolve/LocalDunderClass.py

@@ -0,0 +1,5 @@
+class A:
+    def foo(self):
+        __class__ = 16
+        return __class__
+#                <ref>

python/testData/resolve/TypeClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    my_attr = 15
+
+
+print(A.my_attr)
+#         <ref>

python/testData/resolve/TypeClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    my_attr = 15
+
+
+print(A.my_attr)
+#         <ref>

python/testData/resolve/TypeDunderClass.py

@@ -0,0 +1,6 @@
+class A:
+    pass
+
+
+print(A.__class__)
+#         <ref>

python/testData/resolve/TypeDunderClassNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    pass
+
+
+print(A.__class__)
+#         <ref>

python/testData/resolve/TypeDunderClassWithClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    __class__ = 15
+
+
+print(A.__class__)
+#         <ref>

python/testData/resolve/TypeDunderClassWithClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    __class__ = 15
+
+
+print(A.__class__)
+#         <ref>

python/testData/resolve/TypeDunderClassWithInheritedClassAttr.py

@@ -0,0 +1,9 @@
+class A(object):
+    __class__ = 17
+
+class B(A):
+    pass
+
+
+print(B.__class__)
+#         <ref>

python/testData/resolve/TypeDunderDoc.py

@@ -0,0 +1,6 @@
+class A:
+    pass
+
+
+print(A.__doc__)
+#         <ref>

python/testData/resolve/TypeDunderDocNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    pass
+
+
+print(A.__doc__)
+#         <ref>

python/testData/resolve/TypeDunderDocWithClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    __doc__ = 16
+
+
+print(A.__doc__)
+#         <ref>

python/testData/resolve/TypeDunderDocWithClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    __doc__ = 16
+
+
+print(A.__doc__)
+#         <ref>

python/testData/resolve/TypeDunderDocWithInheritedClassAttr.py

@@ -0,0 +1,9 @@
+class A(object):
+    __doc__ = 17
+
+class B(A):
+    pass
+
+
+print(B.__doc__)
+#         <ref>

python/testData/resolve/TypeDunderSizeOf.py

@@ -0,0 +1,6 @@
+class A:
+    pass
+
+
+print(A.__sizeof__)
+#         <ref>

python/testData/resolve/TypeDunderSizeOfNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    pass
+
+
+print(A.__sizeof__)
+#         <ref>

python/testData/resolve/TypeDunderSizeOfWithClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    __sizeof__ = 16
+
+
+print(A.__sizeof__)
+#         <ref>

python/testData/resolve/TypeDunderSizeOfWithClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    __sizeof__ = 16
+
+
+print(A.__sizeof__)
+#         <ref>

python/testData/resolve/TypeDunderSizeOfWithInheritedClassAttr.py

@@ -0,0 +1,9 @@
+class A(object):
+    __sizeof__ = 17
+
+class B(A):
+    pass
+
+
+print(B.__sizeof__)
+#         <ref>

python/testData/resolve/TypeInheritedClassAttr.py

@@ -0,0 +1,9 @@
+class A(object):
+    my_attr = 17
+
+class B(A):
+    pass
+
+
+print(B.my_attr)
+#         <ref>

python/testData/resolve/TypeUndeclaredClassAttr.py

@@ -0,0 +1,6 @@
+class A:
+    pass
+
+
+print(A.my_attr)
+#         <ref>

python/testData/resolve/TypeUndeclaredClassAttrNewStyleClass.py

@@ -0,0 +1,6 @@
+class A(object):
+    pass
+
+
+print(A.my_attr)
+#         <ref>

python/testData/resolve/UndeclaredClassAttrInDeclaration.py

@@ -0,0 +1,3 @@
+class A:
+    print(my_attr)
+#           <ref>

python/testData/resolve/UndeclaredClassAttrInDeclarationNewStyleClass.py

@@ -0,0 +1,3 @@
+class A(object):
+    print(my_attr)
+#           <ref>

python/testSrc/com/jetbrains/python/Py3ResolveTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2016 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.
@@ -17,11 +17,15 @@ package com.jetbrains.python;
 
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiReference;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.testFramework.LightProjectDescriptor;
 import com.jetbrains.python.fixtures.PyResolveTestCase;
 import com.jetbrains.python.fixtures.PyTestCase;
 import com.jetbrains.python.psi.LanguageLevel;
+import com.jetbrains.python.psi.PyClass;
 import com.jetbrains.python.psi.PyFunction;
+import com.jetbrains.python.psi.PyTargetExpression;
+import com.jetbrains.python.psi.impl.PyBuiltinCache;
 import com.jetbrains.python.psi.impl.PythonLanguageLevelPusher;
 
 /**
@@ -60,4 +64,304 @@ public class Py3ResolveTest extends PyResolveTestCase {
   public void testTrueDiv() {
     assertResolvesTo(PyFunction.class, "__truediv__");
   }
+
+  // PY-13734
+  public void testImplicitDunderClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderDoc() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOf() {
+    assertUnresolved();
+  }
+
+  public void testImplicitUndeclaredClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testImplicitDunderClassWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderDocWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOfWithClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testImplicitClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testImplicitDunderClassWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderDocWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOfWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testImplicitInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testInstanceDunderClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderDoc() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderSizeOf() {
+    final PyFunction expression = assertResolvesTo(PyFunction.class, PyNames.SIZEOF);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceUndeclaredClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testInstanceDunderClassWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderDocWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderSizeOfWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testInstanceDunderClassWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderDocWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderSizeOfWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testLocalDunderClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyFunction function = PsiTreeUtil.getParentOfType(expression, PyFunction.class);
+    assertNotNull(function);
+    assertEquals("foo", function.getName());
+  }
+
+  // PY-13734
+  public void testTypeDunderClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderDoc() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderSizeOf() {
+    final PyFunction expression = assertResolvesTo(PyFunction.class, PyNames.SIZEOF);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testTypeUndeclaredClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testTypeDunderClassWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderDocWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeDunderSizeOfWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testTypeDunderClassWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderDocWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderSizeOfWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclaration() {
+    assertUnresolved();
+  }
+
+  public void testDunderDocInDeclaration() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testDunderSizeOfInDeclaration() {
+    assertUnresolved();
+  }
+
+  public void testUndeclaredClassAttrInDeclaration() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testDunderDocInDeclarationWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testDunderSizeOfInDeclarationWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testClassAttrInDeclaration() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testDunderDocInDeclarationWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE_3K, expression.getContainingFile().getName());
+  }
+
+  public void testDunderSizeOfInDeclarationWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testInheritedClassAttrInDeclaration() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationInsideFunction() {
+    assertUnresolved();
+  }
 }

python/testSrc/com/jetbrains/python/PyResolveTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2016 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.
@@ -26,6 +26,7 @@ import com.jetbrains.python.codeInsight.dataflow.scope.ScopeUtil;
 import com.jetbrains.python.documentation.docstrings.DocStringFormat;
 import com.jetbrains.python.fixtures.PyResolveTestCase;
 import com.jetbrains.python.psi.*;
+import com.jetbrains.python.psi.impl.PyBuiltinCache;
 import com.jetbrains.python.psi.impl.PyPsiUtils;
 import com.jetbrains.python.psi.impl.PythonLanguageLevelPusher;
 import com.jetbrains.python.psi.resolve.ImportedResolveResult;
@@ -406,7 +407,7 @@ public class PyResolveTest extends PyResolveTestCase {
 
   public void testBuiltinVsClassMember() {  // PY-1654
     final PyFunction pyFunction = assertResolvesTo(PyFunction.class, "eval");
-    assertEquals("__builtin__.py", pyFunction.getContainingFile().getName());
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, pyFunction.getContainingFile().getName());
   }
 
   public void testLambdaToClass() {  // PY-2182
@@ -740,4 +741,487 @@ public class PyResolveTest extends PyResolveTestCase {
     assertResolvesTo(PyTargetExpression.class, "foo");
   }
 
+  // PY-13734
+  public void testImplicitDunderClass() {
+    assertUnresolved();
+  }
+
+  public void testImplicitDunderDoc() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOf() {
+    assertUnresolved();
+  }
+
+  public void testImplicitUndeclaredClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testImplicitDunderClassNewStyleClass() {
+    assertUnresolved();
+  }
+
+  public void testImplicitDunderDocNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOfNewStyleClass() {
+    assertUnresolved();
+  }
+
+  public void testImplicitUndeclaredClassAttrNewStyleClass() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testImplicitDunderClassWithClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testImplicitDunderDocWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOfWithClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testImplicitClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testImplicitDunderClassWithClassAttrNewStyleClass() {
+    assertUnresolved();
+  }
+
+  public void testImplicitDunderDocWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOfWithClassAttrNewStyleClass() {
+    assertUnresolved();
+  }
+
+  public void testImplicitClassAttrNewStyleClass() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testImplicitDunderClassWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testImplicitDunderDocWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testImplicitDunderSizeOfWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testImplicitInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testInstanceDunderClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderDoc() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderSizeOf() {
+    assertUnresolved();
+  }
+
+  public void testInstanceUndeclaredClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testInstanceDunderClassNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderDocNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderSizeOfNewStyleClass() {
+    final PyFunction expression = assertResolvesTo(PyFunction.class, PyNames.SIZEOF);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceUndeclaredClassAttrNewStyleClass() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testInstanceDunderClassWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderDocWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderSizeOfWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testInstanceDunderClassWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderDocWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderSizeOfWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testInstanceDunderClassWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceDunderDocWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testInstanceDunderSizeOfWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testInstanceInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testLocalDunderClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyFunction function = PsiTreeUtil.getParentOfType(expression, PyFunction.class);
+    assertNotNull(function);
+    assertEquals("foo", function.getName());
+  }
+
+  // PY-13734
+  public void testTypeDunderClass() {
+    assertUnresolved();
+  }
+
+  public void testTypeDunderDoc() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderSizeOf() {
+    assertUnresolved();
+  }
+
+  public void testTypeUndeclaredClassAttr() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testTypeDunderClassNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderDocNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderSizeOfNewStyleClass() {
+    final PyFunction expression = assertResolvesTo(PyFunction.class, PyNames.SIZEOF);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeUndeclaredClassAttrNewStyleClass() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testTypeDunderClassWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeDunderDocWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeDunderSizeOfWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testTypeDunderClassWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderDocWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeDunderSizeOfWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testTypeDunderClassWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderDocWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testTypeDunderSizeOfWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testTypeInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclaration() {
+    assertUnresolved();
+  }
+
+  public void testDunderDocInDeclaration() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testDunderSizeOfInDeclaration() {
+    assertUnresolved();
+  }
+
+  public void testUndeclaredClassAttrInDeclaration() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationNewStyleClass() {
+    assertUnresolved();
+  }
+
+  public void testDunderDocInDeclarationNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testDunderSizeOfInDeclarationNewStyleClass() {
+    assertUnresolved();
+  }
+
+  public void testUndeclaredClassAttrInDeclarationNewStyleClass() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testDunderDocInDeclarationWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testDunderSizeOfInDeclarationWithClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testClassAttrInDeclaration() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.__CLASS__);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testDunderDocInDeclarationWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testDunderSizeOfInDeclarationWithClassAttrNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.SIZEOF);
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  public void testClassAttrInDeclarationNewStyleClass() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, "my_attr");
+
+    final PyClass cls = expression.getContainingClass();
+    assertNotNull(cls);
+    assertEquals("A", cls.getName());
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testDunderDocInDeclarationWithInheritedClassAttr() {
+    final PyTargetExpression expression = assertResolvesTo(PyTargetExpression.class, PyNames.DOC);
+    assertEquals(PyBuiltinCache.BUILTIN_FILE, expression.getContainingFile().getName());
+  }
+
+  public void testDunderSizeOfInDeclarationWithInheritedClassAttr() {
+    assertUnresolved();
+  }
+
+  public void testInheritedClassAttrInDeclaration() {
+    assertUnresolved();
+  }
+
+  // PY-13734
+  public void testDunderClassInDeclarationInsideFunction() {
+    assertUnresolved();
+  }
 }

python/testSrc/com/jetbrains/python/fixtures/PyResolveTestCase.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2016 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.
@@ -89,6 +89,17 @@ public abstract class PyResolveTestCase extends PyTestCase {
     return assertResolveResult(element, aClass, name, containingFilePath);
   }
 
+  protected void assertUnresolved() {
+    final PsiElement element;
+    try {
+      element = doResolve();
+    }
+    catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+    assertNull(element);
+  }
+
   public static <T extends PsiElement> T assertResolveResult(PsiElement element,
                                                              Class<T> aClass,
                                                              String name) {

python/testSrc/com/jetbrains/python/inspections/Py3UnresolvedReferencesInspectionTest.java

@@ -136,4 +136,9 @@ public class Py3UnresolvedReferencesInspectionTest extends PyTestCase {
   public void testDecodeBytesAfterSlicing() {
     doTest();
   }
+
+  // PY-13734
+  public void testDunderClass() {
+    doTest();
+  }
 }

python/testSrc/com/jetbrains/python/inspections/PyUnresolvedReferencesInspectionTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2013 JetBrains s.r.o.
+ * Copyright 2000-2016 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.
@@ -234,17 +234,17 @@ public class PyUnresolvedReferencesInspectionTest extends PyInspectionTestCase {
 
   // PY-6745
   public void testQualNameAttribute() {
-    runWithLanguageLevel(LanguageLevel.PYTHON33, () -> doTest());
+    runWithLanguageLevel(LanguageLevel.PYTHON33, this::doTest);
   }
 
   // PY-7389
   public void testComprehensionScope27() {
-    runWithLanguageLevel(LanguageLevel.PYTHON27, () -> doTest());
+    runWithLanguageLevel(LanguageLevel.PYTHON27, this::doTest);
   }
 
   // PY-7389
   public void testComprehensionScope33() {
-    runWithLanguageLevel(LanguageLevel.PYTHON33, () -> doTest());
+    runWithLanguageLevel(LanguageLevel.PYTHON33, this::doTest);
   }
 
   // PY-7516
@@ -724,6 +724,11 @@ public class PyUnresolvedReferencesInspectionTest extends PyInspectionTestCase {
     doTest();
   }
 
+  // PY-13734
+  public void testDunderClass() {
+    doTest();
+  }
+
   @NotNull
   @Override
   protected Class<? extends PyInspection> getInspectionClass() {