001    /*
002     * Copyright 2010-2013 JetBrains s.r.o.
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package org.jetbrains.jet.lang.resolve.java.scope;
018    
019    import jet.Function0;
020    import jet.Function1;
021    import kotlin.KotlinPackage;
022    import org.jetbrains.annotations.NotNull;
023    import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
024    import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
025    import org.jetbrains.jet.lang.descriptors.impl.EnumEntrySyntheticClassDescriptor;
026    import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver;
027    import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
028    import org.jetbrains.jet.lang.resolve.java.structure.JavaField;
029    import org.jetbrains.jet.lang.resolve.name.FqName;
030    import org.jetbrains.jet.lang.resolve.name.Name;
031    import org.jetbrains.jet.storage.LockBasedStorageManager;
032    import org.jetbrains.jet.storage.NotNullLazyValue;
033    
034    import java.util.ArrayList;
035    import java.util.Collection;
036    import java.util.List;
037    
038    import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClass;
039    import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES;
040    
041    public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope {
042        @NotNull
043        private final ClassDescriptor descriptor;
044        @NotNull
045        private final JavaClass javaClass;
046    
047        public JavaClassNonStaticMembersScope(
048                @NotNull ClassDescriptor descriptor,
049                @NotNull JavaClass javaClass,
050                @NotNull JavaMemberResolver memberResolver
051        ) {
052            super(descriptor, MembersProvider.forClass(javaClass, false), memberResolver);
053            this.descriptor = descriptor;
054            this.javaClass = javaClass;
055        }
056    
057        @NotNull
058        public Collection<ConstructorDescriptor> getConstructors() {
059            return memberResolver.resolveConstructors(javaClass, descriptor);
060        }
061    
062        @NotNull
063        @Override
064        protected Collection<ClassDescriptor> computeInnerClasses() {
065            Collection<JavaClass> innerClasses = javaClass.getInnerClasses();
066            List<ClassDescriptor> result = new ArrayList<ClassDescriptor>(innerClasses.size());
067            for (JavaClass innerClass : innerClasses) {
068                result.add(resolveInnerClass(innerClass));
069            }
070    
071            if (isEnumClass(descriptor)) {
072                result.addAll(computeEnumEntries());
073            }
074    
075            return result;
076        }
077    
078        private Collection<ClassDescriptor> computeEnumEntries() {
079            List<ClassDescriptor> result = new ArrayList<ClassDescriptor>();
080    
081            final Collection<NamedMembers> enumNonStaticMembers = MembersProvider.forClass(javaClass, true).allMembers();
082    
083            NotNullLazyValue<Collection<Name>> enumMemberNames =
084                    LockBasedStorageManager.NO_LOCKS.createLazyValue(new Function0<Collection<Name>>() {
085                        @Override
086                        public Collection<Name> invoke() {
087                            return KotlinPackage.map(enumNonStaticMembers, new Function1<NamedMembers, Name>() {
088                                @Override
089                                public Name invoke(@NotNull NamedMembers members) {
090                                    return members.getName();
091                                }
092                            });
093                        }
094                    });
095    
096            for (NamedMembers members : enumNonStaticMembers) {
097                for (JavaField field : members.getFields()) {
098                    if (field.isEnumEntry()) {
099                        EnumEntrySyntheticClassDescriptor enumEntry = EnumEntrySyntheticClassDescriptor
100                                .create(LockBasedStorageManager.NO_LOCKS, descriptor, members.getName(), enumMemberNames);
101                        result.add(enumEntry);
102                        break;
103                    }
104                }
105            }
106    
107            return result;
108        }
109    
110        @NotNull
111        private ClassDescriptor resolveInnerClass(@NotNull JavaClass innerClass) {
112            FqName fqName = innerClass.getFqName();
113            assert fqName != null : "Inner class has no qualified name: " + innerClass;
114            ClassDescriptor classDescriptor = memberResolver.resolveClass(fqName, IGNORE_KOTLIN_SOURCES);
115            assert classDescriptor != null : "Couldn't resolve inner class " + fqName;
116            return classDescriptor;
117        }
118    }