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