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.types.expressions;
018
019 import org.jetbrains.annotations.NotNull;
020 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
021 import org.jetbrains.jet.lang.psi.Call;
022 import org.jetbrains.jet.lang.psi.JetReferenceExpression;
023 import org.jetbrains.jet.lang.resolve.BindingTrace;
024 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtension;
025 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
026 import org.jetbrains.jet.lang.resolve.calls.context.*;
027 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
028 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver;
029 import org.jetbrains.jet.lang.resolve.name.Name;
030 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
031 import org.jetbrains.jet.lang.types.JetType;
032
033 public class ExpressionTypingContext extends ResolutionContext<ExpressionTypingContext> {
034
035 @NotNull
036 public static ExpressionTypingContext newContext(
037 @NotNull ExpressionTypingServices expressionTypingServices,
038 @NotNull BindingTrace trace,
039 @NotNull JetScope scope,
040 @NotNull DataFlowInfo dataFlowInfo,
041 @NotNull JetType expectedType,
042 @NotNull ExpressionPosition expressionPosition
043 ) {
044 return newContext(expressionTypingServices, trace, scope, dataFlowInfo, expectedType, expressionPosition,
045 ContextDependency.INDEPENDENT, ResolutionResultsCacheImpl.create(), LabelResolver.create(),
046 expressionTypingServices.createExtension(scope));
047 }
048
049 @NotNull
050 public static ExpressionTypingContext newContext(
051 @NotNull ExpressionTypingServices expressionTypingServices,
052 @NotNull ResolutionContext resolutionContext
053 ) {
054 return newContext(expressionTypingServices, resolutionContext.trace, resolutionContext.scope, resolutionContext.dataFlowInfo,
055 resolutionContext.expectedType, resolutionContext.expressionPosition, resolutionContext.contextDependency,
056 resolutionContext.resolutionResultsCache, resolutionContext.labelResolver,
057 resolutionContext.callResolverExtension);
058 }
059
060 @NotNull
061 public static ExpressionTypingContext newContext(
062 @NotNull ExpressionTypingServices expressionTypingServices,
063 @NotNull BindingTrace trace,
064 @NotNull JetScope scope,
065 @NotNull DataFlowInfo dataFlowInfo,
066 @NotNull JetType expectedType,
067 @NotNull ExpressionPosition expressionPosition,
068 @NotNull ContextDependency contextDependency,
069 @NotNull ResolutionResultsCache resolutionResultsCache,
070 @NotNull LabelResolver labelResolver,
071 @NotNull CallResolverExtension callResolverExtension
072 ) {
073 return new ExpressionTypingContext(
074 expressionTypingServices, labelResolver, trace, scope, dataFlowInfo, expectedType, expressionPosition, contextDependency, resolutionResultsCache,
075 callResolverExtension);
076 }
077
078 public final ExpressionTypingServices expressionTypingServices;
079
080 private CompileTimeConstantResolver compileTimeConstantResolver;
081
082 private ExpressionTypingContext(
083 @NotNull ExpressionTypingServices expressionTypingServices,
084 @NotNull LabelResolver labelResolver,
085 @NotNull BindingTrace trace,
086 @NotNull JetScope scope,
087 @NotNull DataFlowInfo dataFlowInfo,
088 @NotNull JetType expectedType,
089 @NotNull ExpressionPosition expressionPosition,
090 @NotNull ContextDependency contextDependency,
091 @NotNull ResolutionResultsCache resolutionResultsCache,
092 @NotNull CallResolverExtension callResolverExtension
093 ) {
094 super(trace, scope, expectedType, dataFlowInfo, expressionPosition, contextDependency, resolutionResultsCache, labelResolver,
095 callResolverExtension);
096 this.expressionTypingServices = expressionTypingServices;
097 }
098
099 @Override
100 protected ExpressionTypingContext create(
101 @NotNull BindingTrace trace,
102 @NotNull JetScope scope,
103 @NotNull DataFlowInfo dataFlowInfo,
104 @NotNull JetType expectedType,
105 @NotNull ExpressionPosition expressionPosition,
106 @NotNull ContextDependency contextDependency,
107 @NotNull ResolutionResultsCache resolutionResultsCache,
108 @NotNull LabelResolver labelResolver
109 ) {
110 return new ExpressionTypingContext(expressionTypingServices, this.labelResolver, trace, scope, dataFlowInfo, expectedType,
111 expressionPosition, contextDependency, resolutionResultsCache, callResolverExtension);
112 }
113
114 @Override
115 protected ExpressionTypingContext self() {
116 return this;
117 }
118
119 ///////////// LAZY ACCESSORS
120
121 public CompileTimeConstantResolver getCompileTimeConstantResolver() {
122 if (compileTimeConstantResolver == null) {
123 compileTimeConstantResolver = new CompileTimeConstantResolver();
124 }
125 return compileTimeConstantResolver;
126 }
127
128 ////////// Call resolution utilities
129
130 @NotNull
131 public OverloadResolutionResults<FunctionDescriptor> resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull Name name) {
132 return expressionTypingServices.getCallResolver().resolveCallWithGivenName(
133 BasicCallResolutionContext.create(this, call, CheckValueArgumentsMode.ENABLED),
134 functionReference,
135 name
136 );
137 }
138 }