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 kotlin.Function0;
020 import org.jetbrains.annotations.NotNull;
021 import org.jetbrains.jet.codegen.context.CodegenContext;
022 import org.jetbrains.jet.codegen.context.MethodContext;
023 import org.jetbrains.jet.codegen.context.ScriptContext;
024 import org.jetbrains.jet.codegen.state.GenerationState;
025 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
026 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
027 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
028 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
029 import org.jetbrains.jet.lang.psi.*;
030 import org.jetbrains.jet.lang.resolve.BindingContext;
031 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
032 import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
033 import org.jetbrains.org.objectweb.asm.MethodVisitor;
034 import org.jetbrains.org.objectweb.asm.Type;
035 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
036
037 import java.util.Collections;
038 import java.util.List;
039
040 import static org.jetbrains.jet.codegen.AsmUtil.method;
041 import static org.jetbrains.jet.codegen.binding.CodegenBinding.*;
042 import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.*;
043 import static org.jetbrains.jet.lang.resolve.java.diagnostics.DiagnosticsPackage.OtherOrigin;
044 import static org.jetbrains.jet.lang.resolve.java.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
045 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
046
047 // SCRIPT: script code generator
048 public class ScriptCodegen extends MemberCodegen<JetScript> {
049
050 public static ScriptCodegen createScriptCodegen(
051 @NotNull JetScript declaration,
052 @NotNull GenerationState state,
053 @NotNull CodegenContext parentContext
054 ) {
055 ScriptDescriptor scriptDescriptor = state.getBindingContext().get(BindingContext.SCRIPT, declaration);
056 assert scriptDescriptor != null;
057
058 ClassDescriptor classDescriptorForScript = state.getBindingContext().get(CLASS_FOR_SCRIPT, scriptDescriptor);
059 assert classDescriptorForScript != null;
060
061 Type className = state.getBindingContext().get(ASM_TYPE, classDescriptorForScript);
062 assert className != null;
063
064 ClassBuilder builder = state.getFactory().newVisitor(OtherOrigin(declaration, classDescriptorForScript),
065 className, declaration.getContainingFile());
066 List<ScriptDescriptor> earlierScripts = state.getEarlierScriptsForReplInterpreter();
067 ScriptContext scriptContext = parentContext.intoScript(
068 scriptDescriptor,
069 earlierScripts == null ? Collections.<ScriptDescriptor>emptyList() : earlierScripts,
070 classDescriptorForScript
071 );
072 return new ScriptCodegen(declaration, state, scriptContext, builder);
073 }
074
075 private final JetScript scriptDeclaration;
076 private final ScriptContext context;
077 private final ScriptDescriptor scriptDescriptor;
078
079 private ScriptCodegen(
080 @NotNull JetScript scriptDeclaration,
081 @NotNull GenerationState state,
082 @NotNull ScriptContext context,
083 @NotNull ClassBuilder builder
084 ) {
085 super(state, null, context, scriptDeclaration, builder);
086 this.scriptDeclaration = scriptDeclaration;
087 this.context = context;
088 this.scriptDescriptor = context.getScriptDescriptor();
089 }
090
091 @Override
092 protected void generateDeclaration() {
093 Type classType = bindingContext.get(ASM_TYPE, context.getContextDescriptor());
094 assert classType != null;
095
096 v.defineClass(scriptDeclaration,
097 V1_6,
098 ACC_PUBLIC,
099 classType.getInternalName(),
100 null,
101 "java/lang/Object",
102 new String[0]);
103
104 generateReflectionObjectField(state, classType, v, method("kClassFromKotlin", K_CLASS_IMPL_TYPE, getType(Class.class)),
105 JvmAbi.KOTLIN_CLASS_FIELD_NAME, createOrGetClInitCodegen().v);
106 }
107
108 @Override
109 protected void generateBody() {
110 genMembers();
111 genFieldsForParameters(scriptDescriptor, v);
112 genConstructor(scriptDescriptor, context.getContextDescriptor(), v,
113 context.intoFunction(scriptDescriptor.getScriptCodeDescriptor()));
114 }
115
116 @Override
117 protected void generateKotlinAnnotation() {
118 // TODO
119 }
120
121 private void genConstructor(
122 @NotNull ScriptDescriptor scriptDescriptor,
123 @NotNull ClassDescriptor classDescriptorForScript,
124 @NotNull ClassBuilder classBuilder,
125 @NotNull final MethodContext methodContext
126 ) {
127 Type blockType = typeMapper.mapType(scriptDescriptor.getScriptCodeDescriptor().getReturnType());
128
129 PropertyDescriptor scriptResultProperty = scriptDescriptor.getScriptResultProperty();
130 classBuilder.newField(OtherOrigin(scriptResultProperty),
131 ACC_PUBLIC | ACC_FINAL, scriptResultProperty.getName().asString(),
132 blockType.getDescriptor(), null, null);
133
134 JvmMethodSignature jvmSignature = typeMapper.mapScriptSignature(scriptDescriptor, context.getEarlierScripts());
135
136 MethodVisitor mv = classBuilder.newMethod(
137 OtherOrigin(scriptDeclaration, scriptDescriptor.getClassDescriptor().getUnsubstitutedPrimaryConstructor()),
138 ACC_PUBLIC, jvmSignature.getAsmMethod().getName(), jvmSignature.getAsmMethod().getDescriptor(),
139 null, null);
140
141 mv.visitCode();
142
143 final InstructionAdapter iv = new InstructionAdapter(mv);
144
145 Type classType = bindingContext.get(ASM_TYPE, classDescriptorForScript);
146 assert classType != null;
147
148 iv.load(0, classType);
149 iv.invokespecial("java/lang/Object", "<init>", "()V", false);
150
151 iv.load(0, classType);
152
153 final FrameMap frameMap = new FrameMap();
154 frameMap.enterTemp(OBJECT_TYPE);
155
156 for (ScriptDescriptor importedScript : context.getEarlierScripts()) {
157 frameMap.enter(importedScript, OBJECT_TYPE);
158 }
159
160 Type[] argTypes = jvmSignature.getAsmMethod().getArgumentTypes();
161 int add = 0;
162
163 for (int i = 0; i < scriptDescriptor.getScriptCodeDescriptor().getValueParameters().size(); i++) {
164 ValueParameterDescriptor parameter = scriptDescriptor.getScriptCodeDescriptor().getValueParameters().get(i);
165 frameMap.enter(parameter, argTypes[i + add]);
166 }
167
168 generateInitializers(new Function0<ExpressionCodegen>() {
169 @Override
170 public ExpressionCodegen invoke() {
171 return new ExpressionCodegen(iv, frameMap, Type.VOID_TYPE, methodContext, state, ScriptCodegen.this);
172 }
173 });
174
175 int offset = 1;
176
177 for (ScriptDescriptor earlierScript : context.getEarlierScripts()) {
178 Type earlierClassType = asmTypeForScriptDescriptor(bindingContext, earlierScript);
179 iv.load(0, classType);
180 iv.load(offset, earlierClassType);
181 offset += earlierClassType.getSize();
182 iv.putfield(classType.getInternalName(), context.getScriptFieldName(earlierScript), earlierClassType.getDescriptor());
183 }
184
185 for (ValueParameterDescriptor parameter : scriptDescriptor.getScriptCodeDescriptor().getValueParameters()) {
186 Type parameterType = typeMapper.mapType(parameter.getType());
187 iv.load(0, classType);
188 iv.load(offset, parameterType);
189 offset += parameterType.getSize();
190 iv.putfield(classType.getInternalName(), parameter.getName().getIdentifier(), parameterType.getDescriptor());
191 }
192
193 StackValue stackValue =
194 new ExpressionCodegen(mv, frameMap, Type.VOID_TYPE, methodContext, state, this).gen(scriptDeclaration.getBlockExpression());
195 if (stackValue.type != Type.VOID_TYPE) {
196 stackValue.put(blockType, iv);
197 iv.putfield(classType.getInternalName(), ScriptDescriptor.LAST_EXPRESSION_VALUE_FIELD_NAME, blockType.getDescriptor());
198 }
199
200 iv.areturn(Type.VOID_TYPE);
201 mv.visitMaxs(-1, -1);
202 mv.visitEnd();
203 }
204
205 private void genFieldsForParameters(@NotNull ScriptDescriptor script, @NotNull ClassBuilder classBuilder) {
206 for (ScriptDescriptor earlierScript : context.getEarlierScripts()) {
207 Type earlierClassName = asmTypeForScriptDescriptor(bindingContext, earlierScript);
208 int access = ACC_PRIVATE | ACC_FINAL;
209 classBuilder.newField(NO_ORIGIN, access, context.getScriptFieldName(earlierScript), earlierClassName.getDescriptor(), null, null);
210 }
211
212 for (ValueParameterDescriptor parameter : script.getScriptCodeDescriptor().getValueParameters()) {
213 Type parameterType = typeMapper.mapType(parameter);
214 int access = ACC_PUBLIC | ACC_FINAL;
215 classBuilder.newField(OtherOrigin(parameter), access, parameter.getName().getIdentifier(), parameterType.getDescriptor(), null, null);
216 }
217 }
218
219 private void genMembers() {
220 for (JetDeclaration declaration : scriptDeclaration.getDeclarations()) {
221 if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
222 genFunctionOrProperty(declaration);
223 }
224 else if (declaration instanceof JetClassOrObject) {
225 genClassOrObject((JetClassOrObject) declaration);
226 }
227 }
228 }
229 }