Exemplo n.º 1
0
  public static void genNotNullAssertionsForParameters(
      @NotNull InstructionAdapter v,
      @NotNull GenerationState state,
      @NotNull FunctionDescriptor descriptor,
      @NotNull FrameMap frameMap) {
    if (!state.isGenerateNotNullParamAssertions()) return;

    // Private method is not accessible from other classes, no assertions needed
    if (getVisibilityAccessFlag(descriptor) == ACC_PRIVATE) return;

    for (ValueParameterDescriptor parameter : descriptor.getValueParameters()) {
      JetType type = parameter.getReturnType();
      if (type == null || isNullableType(type)) continue;

      int index = frameMap.getIndex(parameter);
      Type asmType = state.getTypeMapper().mapReturnType(type);
      if (asmType.getSort() == Type.OBJECT || asmType.getSort() == Type.ARRAY) {
        v.load(index, asmType);
        v.visitLdcInsn(descriptor.getName().asString());
        v.invokestatic(
            "jet/runtime/Intrinsics",
            "checkParameterIsNotNull",
            "(Ljava/lang/Object;Ljava/lang/String;)V");
      }
    }
  }
Exemplo n.º 2
0
 @NotNull
 public static ClassFileFactory generateFiles(
     @NotNull JetCoreEnvironment environment, @NotNull CodegenTestFiles files) {
   AnalyzeExhaust analyzeExhaust =
       AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationAndCheckForErrors(
           environment.getProject(),
           files.getPsiFiles(),
           files.getScriptParameterTypes(),
           Predicates.<PsiFile>alwaysTrue());
   analyzeExhaust.throwIfError();
   AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
   CompilerConfiguration configuration = environment.getConfiguration();
   GenerationState state =
       new GenerationState(
           environment.getProject(),
           ClassBuilderFactories.TEST,
           Progress.DEAF,
           analyzeExhaust.getBindingContext(),
           files.getPsiFiles(),
           configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, true),
           configuration.get(JVMConfigurationKeys.GENERATE_NOT_NULL_PARAMETER_ASSERTIONS, true),
           /*generateDeclaredClasses = */ true,
           configuration.get(
               JVMConfigurationKeys.ENABLE_INLINE, InlineUtil.DEFAULT_INLINE_FLAG_FOR_TEST));
   KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
   return state.getFactory();
 }
Exemplo n.º 3
0
      @Override
      public StackValue innerValue(
          DeclarationDescriptor d,
          LocalLookup localLookup,
          GenerationState state,
          MutableClosure closure,
          Type classType) {
        VariableDescriptor vd = (VariableDescriptor) d;

        boolean idx = localLookup != null && localLookup.lookupLocal(vd);
        if (!idx) return null;

        Type sharedVarType = state.getTypeMapper().getSharedVarType(vd);
        Type localType = state.getTypeMapper().mapType(vd);
        Type type = sharedVarType != null ? sharedVarType : localType;

        String fieldName = "$" + vd.getName();
        StackValue innerValue =
            sharedVarType != null
                ? StackValue.fieldForSharedVar(localType, classType, fieldName)
                : StackValue.field(type, classType, fieldName, false);

        closure.recordField(fieldName, type);
        closure.captureVariable(new EnclosedValueDescriptor(fieldName, d, innerValue, type));

        return innerValue;
      }
Exemplo n.º 4
0
  public static void genClassOrObject(
      @NotNull CodegenContext parentContext,
      @NotNull JetClassOrObject aClass,
      @NotNull GenerationState state,
      @Nullable MemberCodegen<?> parentCodegen) {
    ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);

    if (descriptor == null || ErrorUtils.isError(descriptor)) {
      badDescriptor(descriptor, state.getClassBuilderMode());
      return;
    }

    if (descriptor.getName().equals(SpecialNames.NO_NAME_PROVIDED)) {
      badDescriptor(descriptor, state.getClassBuilderMode());
    }

    ClassBuilder classBuilder =
        state.getFactory().forClassImplementation(descriptor, aClass.getContainingFile());
    ClassContext classContext =
        parentContext.intoClass(descriptor, OwnerKind.IMPLEMENTATION, state);
    new ImplementationBodyCodegen(aClass, classContext, classBuilder, state, parentCodegen)
        .generate();

    if (aClass instanceof JetClass && ((JetClass) aClass).isTrait()) {
      ClassBuilder traitImplBuilder =
          state.getFactory().forTraitImplementation(descriptor, state, aClass.getContainingFile());
      ClassContext traitImplContext =
          parentContext.intoClass(descriptor, OwnerKind.TRAIT_IMPL, state);
      new TraitImplBodyCodegen(aClass, traitImplContext, traitImplBuilder, state, parentCodegen)
          .generate();
    }
  }
Exemplo n.º 5
0
  private static void registerEarlierScripts(
      @NotNull GenerationState state, @NotNull List<Pair<ScriptDescriptor, Type>> earlierScripts) {
    for (Pair<ScriptDescriptor, Type> t : earlierScripts) {
      ScriptDescriptor earlierDescriptor = t.first;
      Type earlierClassType = t.second;
      registerClassNameForScript(state.getBindingTrace(), earlierDescriptor, earlierClassType);
    }

    List<ScriptDescriptor> earlierScriptDescriptors = Lists.newArrayList();
    for (Pair<ScriptDescriptor, Type> t : earlierScripts) {
      ScriptDescriptor earlierDescriptor = t.first;
      earlierScriptDescriptors.add(earlierDescriptor);
    }
    state.setEarlierScriptsForReplInterpreter(earlierScriptDescriptors);
  }
Exemplo n.º 6
0
      @Override
      public StackValue innerValue(
          DeclarationDescriptor d,
          LocalLookup localLookup,
          GenerationState state,
          MutableClosure closure,
          Type classType) {
        FunctionDescriptor vd = (FunctionDescriptor) d;

        boolean idx = localLookup != null && localLookup.lookupLocal(vd);
        if (!idx) return null;

        BindingContext bindingContext = state.getBindingContext();
        Type localType = asmTypeForAnonymousClass(bindingContext, vd);

        MutableClosure localFunClosure =
            bindingContext.get(CLOSURE, bindingContext.get(CLASS_FOR_FUNCTION, vd));
        if (localFunClosure != null && JvmCodegenUtil.isConst(localFunClosure)) {
          // This is an optimization: we can obtain an instance of a const closure simply by
          // GETSTATIC ...$instance
          // (instead of passing this instance to the constructor and storing as a field)
          return StackValue.field(localType, localType, JvmAbi.INSTANCE_FIELD, true);
        }

        String fieldName = "$" + vd.getName();
        StackValue innerValue = StackValue.field(localType, classType, fieldName, false);

        closure.recordField(fieldName, localType);
        closure.captureVariable(new EnclosedValueDescriptor(fieldName, d, innerValue, localType));

        return innerValue;
      }
Exemplo n.º 7
0
  public static void compileScript(
      @NotNull JetScript script,
      @NotNull Type classType,
      @NotNull List<Pair<ScriptDescriptor, Type>> earlierScripts,
      @NotNull GenerationState state,
      @NotNull CompilationErrorHandler errorHandler) {
    registerEarlierScripts(state, earlierScripts);
    registerClassNameForScript(state.getBindingTrace(), script, classType);

    state.beforeCompile();
    KotlinCodegenFacade.generatePackage(
        state,
        script.getContainingJetFile().getPackageFqName(),
        Collections.singleton(script.getContainingJetFile()),
        errorHandler);
  }
Exemplo n.º 8
0
 protected ClassBodyCodegen(
     JetClassOrObject aClass, CodegenContext context, ClassBuilder v, GenerationState state) {
   super(state);
   descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);
   myClass = aClass;
   this.context = context;
   this.kind = context.getContextKind();
   this.v = v;
 }
Exemplo n.º 9
0
    @NotNull
    @Override
    protected String processRequest(@NotNull Location location) {
      JetFile jetFile = location.getJetFile();
      assert jetFile != null;

      GenerationState state;
      try {
        AnalyzeExhaust exhaust = AnalyzerFacadeWithCache.analyzeFileWithCache(jetFile);
        if (exhaust.isError()) {
          return printStackTraceToString(exhaust.getError());
        }
        state =
            new GenerationState(
                jetFile.getProject(),
                ClassBuilderFactories.TEST,
                Progress.DEAF,
                exhaust.getBindingContext(),
                Collections.singletonList(jetFile),
                true,
                true,
                GenerationState.GenerateClassFilter.GENERATE_ALL,
                enableInline.isSelected());
        KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
      } catch (ProcessCanceledException e) {
        throw e;
      } catch (Exception e) {
        return printStackTraceToString(e);
      }

      StringBuilder answer = new StringBuilder();

      OutputFileCollection outputFiles = state.getFactory();
      for (OutputFile outputFile : outputFiles.asList()) {
        answer.append("// ================");
        answer.append(outputFile.getRelativePath());
        answer.append(" =================\n");
        answer.append(outputFile.asText()).append("\n\n");
      }

      return answer.toString();
    }
Exemplo n.º 10
0
  public void testNoAssertionsForKotlinFromBinary() throws Exception {
    CompilerConfiguration configuration =
        JetTestUtils.compilerConfigurationForTests(
            ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK);
    JetCoreEnvironment tmpEnvironment =
        new JetCoreEnvironment(getTestRootDisposable(), configuration);
    GenerationState state =
        generateCommon(
            ClassBuilderFactories.TEST,
            tmpEnvironment,
            CodegenTestFiles.create(
                tmpEnvironment.getProject(),
                new String[] {"notNullAssertions/noAssertionsForKotlin.kt"}));
    File compiledDirectory = new File(FileUtil.getTempDirectory(), "kotlin-classes");
    CompileEnvironmentUtil.writeToOutputDirectory(state.getFactory(), compiledDirectory);

    setUpEnvironment(true, false, compiledDirectory);

    loadFile("notNullAssertions/noAssertionsForKotlinMain.kt");

    assertNoIntrinsicsMethodIsCalled(PackageClassUtils.getPackageClassName(FqName.ROOT));
  }
Exemplo n.º 11
0
 @Override
 public StackValue generate(
     ExpressionCodegen codegen,
     InstructionAdapter v,
     @NotNull Type expectedType,
     PsiElement element,
     List<JetExpression> arguments,
     StackValue receiver,
     @NotNull GenerationState state) {
   final CallableMethod callableMethod =
       state.getTypeMapper().mapToCallableMethod(method, false, OwnerKind.IMPLEMENTATION);
   codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver);
   return StackValue.onStack(callableMethod.getSignature().getAsmMethod().getReturnType());
 }
Exemplo n.º 12
0
  private static void genNotNullAssertion(
      @NotNull InstructionAdapter v,
      @NotNull GenerationState state,
      @NotNull CallableDescriptor descriptor,
      @NotNull String assertMethodToCall) {
    if (!state.isGenerateNotNullAssertions()) return;

    if (!isDeclaredInJava(descriptor, state.getBindingContext())) return;

    JetType type = descriptor.getReturnType();
    if (type == null || isNullableType(type)) return;

    Type asmType = state.getTypeMapper().mapReturnType(type);
    if (asmType.getSort() == Type.OBJECT || asmType.getSort() == Type.ARRAY) {
      v.dup();
      v.visitLdcInsn(descriptor.getContainingDeclaration().getName().asString());
      v.visitLdcInsn(descriptor.getName().asString());
      v.invokestatic(
          "jet/runtime/Intrinsics",
          assertMethodToCall,
          "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V");
    }
  }
Exemplo n.º 13
0
 @Override
 public final void generateBody(
     @NotNull MethodVisitor mv,
     @NotNull JvmMethodSignature signature,
     @NotNull MethodContext context,
     @Nullable MemberCodegen<?> parentCodegen) {
   ExpressionCodegen codegen =
       new ExpressionCodegen(
           mv,
           getFrameMap(state.getTypeMapper(), context),
           signature.getReturnType(),
           context,
           state,
           parentCodegen);
   doGenerateBody(codegen, signature);
 }
Exemplo n.º 14
0
      @Override
      public StackValue innerValue(
          DeclarationDescriptor d,
          LocalLookup enclosingLocalLookup,
          GenerationState state,
          MutableClosure closure,
          Type classType) {
        if (closure.getEnclosingReceiverDescriptor() != d) return null;

        JetType receiverType = ((CallableDescriptor) d).getReceiverParameter().getType();
        Type type = state.getTypeMapper().mapType(receiverType);
        StackValue innerValue = StackValue.field(type, classType, CAPTURED_RECEIVER_FIELD, false);
        closure.setCaptureReceiver();

        return innerValue;
      }
Exemplo n.º 15
0
  @NotNull
  public LineResult eval(@NotNull String line) {
    ++lineNumber;

    FqName scriptFqName = new FqName("Line" + lineNumber);
    Type scriptClassType = asmTypeByFqNameWithoutInnerClasses(scriptFqName);

    StringBuilder fullText = new StringBuilder();
    for (String prevLine : previousIncompleteLines) {
      fullText.append(prevLine + "\n");
    }
    fullText.append(line);

    LightVirtualFile virtualFile =
        new LightVirtualFile(
            "line" + lineNumber + JetParserDefinition.STD_SCRIPT_EXT,
            JetLanguage.INSTANCE,
            fullText.toString());
    virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
    JetFile psiFile =
        (JetFile)
            ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject()))
                .trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);

    MessageCollectorToString errorCollector = new MessageCollectorToString();

    AnalyzerWithCompilerReport.SyntaxErrorReport syntaxErrorReport =
        AnalyzerWithCompilerReport.reportSyntaxErrors(psiFile, errorCollector);

    if (syntaxErrorReport.isOnlyErrorAtEof()) {
      previousIncompleteLines.add(line);
      return LineResult.incomplete();
    }

    previousIncompleteLines.clear();

    if (syntaxErrorReport.isHasErrors()) {
      return LineResult.error(errorCollector.getString());
    }

    prepareForTheNextReplLine(topDownAnalysisContext);
    trace.clearDiagnostics();

    psiFile.getScript().putUserData(ScriptHeaderResolver.PRIORITY_KEY, lineNumber);

    ScriptDescriptor scriptDescriptor = doAnalyze(psiFile, errorCollector);
    if (scriptDescriptor == null) {
      return LineResult.error(errorCollector.getString());
    }

    List<Pair<ScriptDescriptor, Type>> earlierScripts = Lists.newArrayList();

    for (EarlierLine earlierLine : earlierLines) {
      earlierScripts.add(
          Pair.create(earlierLine.getScriptDescriptor(), earlierLine.getClassType()));
    }

    BindingContext bindingContext =
        AnalyzeExhaust.success(trace.getBindingContext(), module).getBindingContext();
    GenerationState generationState =
        new GenerationState(
            psiFile.getProject(),
            ClassBuilderFactories.BINARIES,
            bindingContext,
            Collections.singletonList(psiFile),
            CompilerArgumentsUtil.DEFAULT_INLINE_FLAG);

    compileScript(
        psiFile.getScript(),
        scriptClassType,
        earlierScripts,
        generationState,
        CompilationErrorHandler.THROW_EXCEPTION);

    for (OutputFile outputFile : generationState.getFactory().asList()) {
      classLoader.addClass(
          JvmClassName.byInternalName(outputFile.getRelativePath().replaceFirst("\\.class$", "")),
          outputFile.asByteArray());
    }

    try {
      Class<?> scriptClass = classLoader.loadClass(scriptFqName.asString());

      Class<?>[] constructorParams = new Class<?>[earlierLines.size()];
      Object[] constructorArgs = new Object[earlierLines.size()];

      for (int i = 0; i < earlierLines.size(); ++i) {
        constructorParams[i] = earlierLines.get(i).getScriptClass();
        constructorArgs[i] = earlierLines.get(i).getScriptInstance();
      }

      Constructor<?> scriptInstanceConstructor = scriptClass.getConstructor(constructorParams);
      Object scriptInstance;
      try {
        scriptInstance = scriptInstanceConstructor.newInstance(constructorArgs);
      } catch (Throwable e) {
        return LineResult.error(Throwables.getStackTraceAsString(e));
      }
      Field rvField = scriptClass.getDeclaredField("rv");
      rvField.setAccessible(true);
      Object rv = rvField.get(scriptInstance);

      earlierLines.add(
          new EarlierLine(line, scriptDescriptor, scriptClass, scriptInstance, scriptClassType));

      return LineResult.successful(
          rv,
          KotlinBuiltIns.getInstance()
              .getUnitType()
              .equals(scriptDescriptor.getScriptCodeDescriptor().getReturnType()));
    } catch (Throwable e) {
      PrintWriter writer = new PrintWriter(System.err);
      classLoader.dumpClasses(writer);
      writer.flush();
      throw UtilsPackage.rethrow(e);
    }
  }