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.codegen;
018
019 import com.google.common.collect.ImmutableMap;
020 import org.jetbrains.annotations.NotNull;
021 import org.jetbrains.annotations.Nullable;
022 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
023 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
024 import org.jetbrains.jet.lang.psi.*;
025 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
026 import org.jetbrains.jet.lang.resolve.name.FqName;
027 import org.jetbrains.jet.lang.resolve.name.Name;
028 import org.jetbrains.jet.lang.types.JetType;
029 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
030 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
031
032 import java.util.List;
033
034 import static org.jetbrains.jet.codegen.AsmUtil.isPrimitiveNumberClassDescriptor;
035
036 public class RangeCodegenUtil {
037 private static final ImmutableMap<FqName, PrimitiveType> RANGE_TO_ELEMENT_TYPE;
038 private static final ImmutableMap<FqName, PrimitiveType> PROGRESSION_TO_ELEMENT_TYPE;
039
040 static {
041 ImmutableMap.Builder<FqName, PrimitiveType> rangeBuilder = ImmutableMap.builder();
042 ImmutableMap.Builder<FqName, PrimitiveType> progressionBuilder = ImmutableMap.builder();
043 for (PrimitiveType primitiveType : PrimitiveType.values()) {
044 rangeBuilder.put(getRangeClassFqName(primitiveType), primitiveType);
045 progressionBuilder.put(getProgressionClassFqName(primitiveType), primitiveType);
046 }
047 RANGE_TO_ELEMENT_TYPE = rangeBuilder.build();
048 PROGRESSION_TO_ELEMENT_TYPE = progressionBuilder.build();
049 }
050
051 private RangeCodegenUtil() {}
052
053 public static boolean isRange(JetType rangeType) {
054 return !rangeType.isNullable() && getPrimitiveRangeElementType(rangeType) != null;
055 }
056
057 public static boolean isProgression(JetType rangeType) {
058 return !rangeType.isNullable() && getPrimitiveProgressionElementType(rangeType) != null;
059 }
060
061 @Nullable
062 public static BinaryCall getRangeAsBinaryCall(@NotNull JetForExpression forExpression) {
063 // We are looking for rangeTo() calls
064 // Other binary operations will succeed too, but will be filtered out later (by examining a resolvedCall)
065 JetExpression rangeExpression = forExpression.getLoopRange();
066 assert rangeExpression != null;
067 JetExpression loopRange = JetPsiUtil.deparenthesize(rangeExpression);
068 if (loopRange instanceof JetQualifiedExpression) {
069 // a.rangeTo(b)
070 JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) loopRange;
071 JetExpression selector = qualifiedExpression.getSelectorExpression();
072 if (selector instanceof JetCallExpression) {
073 JetCallExpression callExpression = (JetCallExpression) selector;
074 List<? extends ValueArgument> arguments = callExpression.getValueArguments();
075 if (arguments.size() == 1) {
076 return new BinaryCall(qualifiedExpression.getReceiverExpression(), callExpression.getCalleeExpression(),
077 arguments.get(0).getArgumentExpression());
078 }
079 }
080 }
081 else if (loopRange instanceof JetBinaryExpression) {
082 // a rangeTo b
083 // a .. b
084 JetBinaryExpression binaryExpression = (JetBinaryExpression) loopRange;
085 return new BinaryCall(binaryExpression.getLeft(), binaryExpression.getOperationReference(), binaryExpression.getRight());
086
087 }
088 return null;
089 }
090
091 @Nullable
092 private static PrimitiveType getPrimitiveRangeElementType(JetType rangeType) {
093 return getPrimitiveRangeOrProgressionElementType(rangeType, RANGE_TO_ELEMENT_TYPE);
094 }
095
096 @Nullable
097 private static PrimitiveType getPrimitiveProgressionElementType(JetType rangeType) {
098 return getPrimitiveRangeOrProgressionElementType(rangeType, PROGRESSION_TO_ELEMENT_TYPE);
099 }
100
101 @Nullable
102 private static PrimitiveType getPrimitiveRangeOrProgressionElementType(
103 @NotNull JetType rangeOrProgression,
104 @NotNull ImmutableMap<FqName, PrimitiveType> map
105 ) {
106 ClassifierDescriptor declarationDescriptor = rangeOrProgression.getConstructor().getDeclarationDescriptor();
107 assert declarationDescriptor != null;
108 if (declarationDescriptor != KotlinBuiltIns.getInstance().getBuiltInsScope().getClassifier(declarationDescriptor.getName())) {
109 // Must be a standard library class
110 return null;
111 }
112 return map.get(DescriptorUtils.getFQName(declarationDescriptor).toSafe());
113 }
114
115 public static boolean isOptimizableRangeTo(CallableDescriptor rangeTo) {
116 if ("rangeTo".equals(rangeTo.getName().asString())) {
117 if (isPrimitiveNumberClassDescriptor(rangeTo.getContainingDeclaration())) {
118 return true;
119 }
120 }
121 return false;
122 }
123
124 @NotNull
125 public static FqName getRangeClassFqName(@NotNull PrimitiveType type) {
126 return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(type.getTypeName() + "Range"));
127 }
128
129 @NotNull
130 public static FqName getProgressionClassFqName(@NotNull PrimitiveType type) {
131 return KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.child(Name.identifier(type.getTypeName() + "Progression"));
132 }
133
134 public static class BinaryCall {
135 public final JetExpression left;
136 public final JetExpression op;
137 public final JetExpression right;
138
139 private BinaryCall(JetExpression left, JetExpression op, JetExpression right) {
140 this.left = left;
141 this.op = op;
142 this.right = right;
143 }
144 }
145 }