From 8ed9a89d9e6d0a1797b3ac09f4df7e134b759097 Mon Sep 17 00:00:00 2001 From: Alex Tkachman Date: Fri, 30 Mar 2012 18:40:56 +0300 Subject: [PATCH] intrinsics for array constructors (half way for array annotations) --- .../jet/codegen/ExpressionCodegen.java | 34 ++++++----- .../codegen/intrinsics/IntrinsicMethods.java | 1 + .../codegen/intrinsics/JavaClassArray.java | 57 +++++++++++++++++++ libraries/stdlib/src/kotlin/Arrays.kt | 20 ++++--- 4 files changed, 88 insertions(+), 24 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 3e4e8831d06..3005e9e2c4f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1511,21 +1511,7 @@ public class ExpressionCodegen extends JetVisitor { } else if(resolvedValueArgument instanceof VarargValueArgument) { VarargValueArgument valueArgument = (VarargValueArgument) resolvedValueArgument; - JetType outType = valueParameterDescriptor.getType(); - - Type type = asmType(outType); - assert type.getSort() == Type.ARRAY; - Type elementType = correctElementType(type); - int size = valueArgument.getArguments().size(); - - v.iconst(valueArgument.getArguments().size()); - v.newarray(elementType); - for(int i = 0; i != size; ++i) { - v.dup(); - v.iconst(i); - gen(valueArgument.getArguments().get(i).getArgumentExpression(), elementType); - StackValue.arrayElement(elementType, false).store(v); - } + genVarargs(valueParameterDescriptor, valueArgument); } else { throw new UnsupportedOperationException(); @@ -1535,6 +1521,24 @@ public class ExpressionCodegen extends JetVisitor { return mask; } + public void genVarargs(ValueParameterDescriptor valueParameterDescriptor, VarargValueArgument valueArgument) { + JetType outType = valueParameterDescriptor.getType(); + + Type type = asmType(outType); + assert type.getSort() == Type.ARRAY; + Type elementType = correctElementType(type); + int size = valueArgument.getArguments().size(); + + v.iconst(valueArgument.getArguments().size()); + v.newarray(elementType); + for(int i = 0; i != size; ++i) { + v.dup(); + v.iconst(i); + gen(valueArgument.getArguments().get(i).getArgumentExpression(), elementType); + StackValue.arrayElement(elementType, false).store(v); + } + } + public int pushMethodArguments(JetCallElement expression, List valueParameterTypes) { ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); if(resolvedCall != null) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java index d178a563a8a..6f30e4fb87f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java @@ -85,6 +85,7 @@ public class IntrinsicMethods { public void init() { namedMethods.put("kotlin.javaClass.function", new JavaClassFunction()); namedMethods.put("kotlin.javaClass.property", new JavaClassProperty()); + namedMethods.put("kotlin.arrays.array", new JavaClassArray()); List primitiveCastMethods = OperatorConventions.NUMBER_CONVERSIONS.asList(); for (String method : primitiveCastMethods) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java new file mode 100644 index 00000000000..9ebb809cfa1 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java @@ -0,0 +1,57 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.codegen.intrinsics; + +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.codegen.ExpressionCodegen; +import org.jetbrains.jet.codegen.GenerationState; +import org.jetbrains.jet.codegen.StackValue; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.psi.JetCallExpression; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedValueArgument; +import org.jetbrains.jet.lang.resolve.calls.VarargValueArgument; +import org.objectweb.asm.Type; +import org.objectweb.asm.commons.InstructionAdapter; + +import java.util.List; +import java.util.Map; + +/** + * @author alex.tkachman + */ +public class JavaClassArray implements IntrinsicMethod { + @Override + public StackValue generate(ExpressionCodegen codegen, + InstructionAdapter v, + Type expectedType, + @Nullable PsiElement element, + @Nullable List arguments, + StackValue receiver, + @NotNull GenerationState state) { + ResolvedCall call = + codegen.getBindingContext().get(BindingContext.RESOLVED_CALL, ((JetCallExpression)element).getCalleeExpression()); + Map.Entry next = call.getValueArguments().entrySet().iterator().next(); + codegen.genVarargs(next.getKey(), (VarargValueArgument)next.getValue()); + return StackValue.onStack(expectedType); + } +} diff --git a/libraries/stdlib/src/kotlin/Arrays.kt b/libraries/stdlib/src/kotlin/Arrays.kt index d8484f064f4..b6b803217e7 100644 --- a/libraries/stdlib/src/kotlin/Arrays.kt +++ b/libraries/stdlib/src/kotlin/Arrays.kt @@ -7,25 +7,27 @@ import java.nio.charset.Charset import java.util.List import java.util.ArrayList +import jet.runtime.Intrinsic + // Array "constructor" -public inline fun array(vararg t : T) : Array = t +[Intrinsic("kotlin.arrays.array")] public inline fun array(vararg t : T) : Array = t // "constructors" for primitive types array -public inline fun doubleArray(vararg content : Double) : DoubleArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun doubleArray(vararg content : Double) : DoubleArray = content -public inline fun floatArray(vararg content : Float) : FloatArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun floatArray(vararg content : Float) : FloatArray = content -public inline fun longArray(vararg content : Long) : LongArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun longArray(vararg content : Long) : LongArray = content -public inline fun intArray(vararg content : Int) : IntArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun intArray(vararg content : Int) : IntArray = content -public inline fun charArray(vararg content : Char) : CharArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun charArray(vararg content : Char) : CharArray = content -public inline fun shortArray(vararg content : Short) : ShortArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun shortArray(vararg content : Short) : ShortArray = content -public inline fun byteArray(vararg content : Byte) : ByteArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun byteArray(vararg content : Byte) : ByteArray = content -public inline fun booleanArray(vararg content : Boolean) : BooleanArray = content +[Intrinsic("kotlin.arrays.array")] public inline fun booleanArray(vararg content : Boolean) : BooleanArray = content public inline fun ByteArray.binarySearch(key: Byte) : Int = Arrays.binarySearch(this, key) public inline fun ShortArray.binarySearch(key: Short) : Int = Arrays.binarySearch(this, key)