001    /*
002     * Copyright 2010-2014 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.lazy.descriptors;
018    
019    import com.google.common.collect.Sets;
020    import com.intellij.psi.util.PsiTreeUtil;
021    import org.jetbrains.annotations.NotNull;
022    import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
023    import org.jetbrains.jet.lang.descriptors.impl.AbstractLazyTypeParameterDescriptor;
024    import org.jetbrains.jet.lang.psi.*;
025    import org.jetbrains.jet.lang.resolve.BindingContext;
026    import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil;
027    import org.jetbrains.jet.lang.resolve.lazy.LazyEntity;
028    import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
029    import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
030    import org.jetbrains.jet.lang.types.JetType;
031    import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
032    import org.jetbrains.jet.lexer.JetTokens;
033    
034    import java.util.Set;
035    
036    public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescriptor implements TypeParameterDescriptor, LazyEntity {
037        private final ResolveSession resolveSession;
038    
039        private final JetTypeParameter jetTypeParameter;
040    
041        public LazyTypeParameterDescriptor(
042                @NotNull ResolveSession resolveSession,
043                @NotNull LazyClassDescriptor containingDeclaration,
044                @NotNull JetTypeParameter jetTypeParameter,
045                int index) {
046            super(
047                    resolveSession.getStorageManager(),
048                    containingDeclaration,
049                    ResolveSessionUtils.safeNameForLazyResolve(jetTypeParameter.getNameAsName()),
050                    jetTypeParameter.getVariance(),
051                    jetTypeParameter.hasModifier(JetTokens.REIFIED_KEYWORD),
052                    index
053            );
054            this.resolveSession = resolveSession;
055            this.jetTypeParameter = jetTypeParameter;
056    
057            this.resolveSession.getTrace().record(BindingContext.TYPE_PARAMETER, jetTypeParameter, this);
058        }
059    
060        @NotNull
061        @Override
062        protected Set<JetType> resolveUpperBounds() {
063            Set<JetType> upperBounds = Sets.newLinkedHashSet();
064    
065            JetTypeParameter jetTypeParameter = this.jetTypeParameter;
066    
067            resolveUpperBoundsFromWhereClause(upperBounds, false);
068    
069            JetTypeReference extendsBound = jetTypeParameter.getExtendsBound();
070            if (extendsBound != null) {
071                upperBounds.add(resolveBoundType(extendsBound));
072            }
073    
074            if (upperBounds.isEmpty()) {
075                upperBounds.add(KotlinBuiltIns.getInstance().getDefaultBound());
076            }
077    
078            return upperBounds;
079        }
080    
081        private void resolveUpperBoundsFromWhereClause(Set<JetType> upperBounds, boolean forClassObject) {
082            JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(jetTypeParameter, JetClassOrObject.class);
083            if (classOrObject instanceof JetClass) {
084                JetClass jetClass = (JetClass) classOrObject;
085                for (JetTypeConstraint jetTypeConstraint : jetClass.getTypeConstraints()) {
086                    if (jetTypeConstraint.isClassObjectConstraint() != forClassObject) continue;
087    
088                    JetSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName();
089                    if (constrainedParameterName != null) {
090                        if (getName().equals(constrainedParameterName.getReferencedNameAsName())) {
091    
092                            JetTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference();
093                            if (boundTypeReference != null) {
094                                upperBounds.add(resolveBoundType(boundTypeReference));
095                            }
096                        }
097                    }
098                }
099            }
100    
101        }
102    
103        private JetType resolveBoundType(@NotNull JetTypeReference boundTypeReference) {
104            return resolveSession.getTypeResolver()
105                        .resolveType(getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference,
106                                     resolveSession.getTrace(), false);
107        }
108    
109        @NotNull
110        @Override
111        public LazyClassDescriptor getContainingDeclaration() {
112            return (LazyClassDescriptor) super.getContainingDeclaration();
113        }
114    
115        @Override
116        public void forceResolveAllContents() {
117            ForceResolveUtil.forceResolveAllContents(getAnnotations());
118            ForceResolveUtil.forceResolveAllContents(getClassObjectType());
119            getContainingDeclaration();
120            getDefaultType();
121            getIndex();
122            getLowerBounds();
123            getLowerBoundsAsType();
124            getOriginal();
125            ForceResolveUtil.forceResolveAllContents(getTypeConstructor());
126            getUpperBounds();
127            getUpperBoundsAsType();
128            getVariance();
129        }
130    }