Remove unused PyTypeFromUsedAttributesHelper and its tests
[idea/community.git] / python / src / com / jetbrains / python / psi / impl / stubs / PyClassElementType.java
1 /*
2  * Copyright 2000-2014 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.jetbrains.python.psi.impl.stubs;
17
18 import com.intellij.lang.ASTNode;
19 import com.intellij.psi.PsiElement;
20 import com.intellij.psi.stubs.*;
21 import com.intellij.psi.util.QualifiedName;
22 import com.intellij.util.io.StringRef;
23 import com.jetbrains.python.PyElementTypes;
24 import com.jetbrains.python.psi.*;
25 import com.jetbrains.python.psi.impl.PyClassImpl;
26 import com.jetbrains.python.psi.impl.PyPsiUtils;
27 import com.jetbrains.python.psi.stubs.*;
28 import org.jetbrains.annotations.NotNull;
29
30 import java.io.IOException;
31 import java.util.ArrayList;
32 import java.util.List;
33
34 /**
35  * @author max
36  */
37 public class PyClassElementType extends PyStubElementType<PyClassStub, PyClass> {
38
39   public PyClassElementType() {
40     this("CLASS_DECLARATION");
41   }
42
43   public PyClassElementType(String debugName) {
44     super(debugName);
45   }
46
47   public PsiElement createElement(@NotNull final ASTNode node) {
48     return new PyClassImpl(node);
49   }
50
51   public PyClass createPsi(@NotNull final PyClassStub stub) {
52     return new PyClassImpl(stub);
53   }
54
55   public PyClassStub createStub(@NotNull final PyClass psi, final StubElement parentStub) {
56     final PyExpression[] exprs = psi.getSuperClassExpressions();
57     List<QualifiedName> superClasses = new ArrayList<QualifiedName>();
58     for (PyExpression expression : exprs) {
59       if (expression instanceof PyKeywordArgument) {
60         continue;
61       }
62       expression = PyClassImpl.unfoldClass(expression);
63       superClasses.add(PyPsiUtils.asQualifiedName(expression));
64     }
65     final PyStringLiteralExpression docStringExpression = psi.getDocStringExpression();
66     return new PyClassStubImpl(psi.getName(), parentStub,
67                                superClasses.toArray(new QualifiedName[superClasses.size()]),
68                                PyPsiUtils.asQualifiedName(psi.getMetaClassExpression()),
69                                psi.getOwnSlots(),
70                                PyPsiUtils.strValue(docStringExpression),
71                                getStubElementType());
72   }
73
74   public void serialize(@NotNull final PyClassStub pyClassStub, @NotNull final StubOutputStream dataStream) throws IOException {
75     dataStream.writeName(pyClassStub.getName());
76     final QualifiedName[] classes = pyClassStub.getSuperClasses();
77     dataStream.writeByte(classes.length);
78     for (QualifiedName s : classes) {
79       QualifiedName.serialize(s, dataStream);
80     }
81     QualifiedName.serialize(pyClassStub.getMetaClass(), dataStream);
82     PyFileElementType.writeNullableList(dataStream, pyClassStub.getSlots());
83     final String docString = pyClassStub.getDocString();
84     dataStream.writeUTFFast(docString != null ? docString : "");
85   }
86
87   @NotNull
88   public PyClassStub deserialize(@NotNull final StubInputStream dataStream, final StubElement parentStub) throws IOException {
89     String name = StringRef.toString(dataStream.readName());
90     int superClassCount = dataStream.readByte();
91     QualifiedName[] superClasses = new QualifiedName[superClassCount];
92     for (int i = 0; i < superClassCount; i++) {
93       superClasses[i] = QualifiedName.deserialize(dataStream);
94     }
95     final QualifiedName metaClass = QualifiedName.deserialize(dataStream);
96     List<String> slots = PyFileElementType.readNullableList(dataStream);
97     final String docString = dataStream.readUTFFast();
98     return new PyClassStubImpl(name, parentStub, superClasses, metaClass, slots, docString.length() > 0 ? docString : null,
99                                getStubElementType());
100   }
101
102   public void indexStub(@NotNull final PyClassStub stub, @NotNull final IndexSink sink) {
103     final String name = stub.getName();
104     if (name != null) {
105       sink.occurrence(PyClassNameIndex.KEY, name);
106       sink.occurrence(PyClassNameIndexInsensitive.KEY, name.toLowerCase());
107     }
108     final PyClass pyClass = createPsi(stub);
109     for (String attribute: PyClassAttributesIndex.getAllDeclaredAttributeNames(pyClass)) {
110       sink.occurrence(PyClassAttributesIndex.KEY, attribute);
111     }
112     for (QualifiedName s : stub.getSuperClasses()) {
113       if (s != null) {
114         String className = s.getLastComponent();
115         if (className != null) {
116           sink.occurrence(PySuperClassIndex.KEY, className);
117         }
118       }
119     }
120   }
121
122   protected IStubElementType getStubElementType() {
123     return PyElementTypes.CLASS_DECLARATION;
124   }
125 }