diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 3b66d4ce869..8c89653e336 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -17,6 +17,7 @@ + diff --git a/.idea/modules.xml b/.idea/modules.xml index 94213936f8b..a7a32bf50d1 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -6,6 +6,7 @@ + diff --git a/TeamCityBuild.xml b/TeamCityBuild.xml index f9ab064f01b..a37cd929ec5 100644 --- a/TeamCityBuild.xml +++ b/TeamCityBuild.xml @@ -10,7 +10,7 @@ - + diff --git a/bin/kotlin b/bin/kotlin index e456ffbe73d..5cca3809cde 100755 --- a/bin/kotlin +++ b/bin/kotlin @@ -24,7 +24,7 @@ classpath="$classpath:$root/lib/*:$ideaRoot/lib/*:$ideaRoot/lib/rt/*" exec java $JAVA_OPTS \ -classpath "$classpath" \ - org.jetbrains.jet.cli.KotlinCompiler \ + org.jetbrains.jet.cli.jvm.K2JVMCompiler \ "$@" # vim: set ts=4 sw=4 et: diff --git a/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java b/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java index 95c745b429c..7d0099cf964 100644 --- a/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java +++ b/build-tools/ant/src/org/jetbrains/jet/buildtools/ant/BytecodeCompilerTask.java @@ -21,7 +21,7 @@ import org.apache.tools.ant.Task; import org.apache.tools.ant.types.Path; import org.apache.tools.ant.types.Reference; import org.jetbrains.jet.buildtools.core.BytecodeCompiler; -import org.jetbrains.jet.compiler.CompileEnvironmentException; +import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentException; import java.io.File; diff --git a/build-tools/build-tools.iml b/build-tools/build-tools.iml index d184270053f..d0304c4b431 100644 --- a/build-tools/build-tools.iml +++ b/build-tools/build-tools.iml @@ -10,6 +10,7 @@ + diff --git a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java index 8617f13f719..d03683a331b 100644 --- a/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java +++ b/build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java @@ -16,10 +16,12 @@ package org.jetbrains.jet.buildtools.core; +import jet.modules.Module; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.compiler.*; -import org.jetbrains.jet.compiler.messages.MessageCollector; +import org.jetbrains.jet.cli.common.CompilerPlugin; +import org.jetbrains.jet.cli.jvm.compiler.*; +import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; @@ -40,7 +42,7 @@ public class BytecodeCompiler { /** - * Creates new instance of {@link org.jetbrains.jet.compiler.CompileEnvironmentConfiguration} instance using the arguments specified. + * Creates new instance of {@link org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration} instance using the arguments specified. * * @param stdlib path to "kotlin-runtime.jar", only used if not null and not empty * @param classpath compilation classpath, only used if not null and not empty @@ -128,7 +130,7 @@ public class BytecodeCompiler { /** - * {@code CompileEnvironment#compileModuleScript} wrapper. + * {@code CompileEnvironment#compileModules} wrapper. * * @param module compilation module file * @param jar compilation destination jar @@ -139,7 +141,9 @@ public class BytecodeCompiler { public void moduleToJar ( @NotNull String module, @NotNull String jar, boolean includeRuntime, @Nullable String stdlib, @Nullable String[] classpath ) { try { CompileEnvironmentConfiguration env = env(stdlib, classpath); - boolean success = KotlinToJVMBytecodeCompiler.compileModuleScript(env, module, jar, null, includeRuntime); + List modules = CompileEnvironmentUtil.loadModuleScript(module, env.getMessageCollector()); + File directory = new File(module).getParentFile(); + boolean success = KotlinToJVMBytecodeCompiler.compileModules(env, modules, directory, jar, null, includeRuntime); if ( ! success ) { throw new CompileEnvironmentException( errorMessage( module, false )); } diff --git a/build.xml b/build.xml index f5260c35565..cdee4e237a9 100644 --- a/build.xml +++ b/build.xml @@ -54,7 +54,7 @@ - + @@ -72,7 +72,7 @@ - + @@ -88,7 +88,7 @@ - + @@ -210,7 +210,7 @@ - + diff --git a/compiler/backend/src/org/jetbrains/jet/compiler/TipsManager.java b/compiler/backend/src/org/jetbrains/jet/cli/jvm/compiler/TipsManager.java similarity index 99% rename from compiler/backend/src/org/jetbrains/jet/compiler/TipsManager.java rename to compiler/backend/src/org/jetbrains/jet/cli/jvm/compiler/TipsManager.java index 8b6cb8c4a16..3e7972e5e28 100644 --- a/compiler/backend/src/org/jetbrains/jet/compiler/TipsManager.java +++ b/compiler/backend/src/org/jetbrains/jet/cli/jvm/compiler/TipsManager.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.google.common.base.Predicate; import com.google.common.collect.Collections2; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java index ea431b29b9b..82415fce97e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java @@ -90,9 +90,10 @@ public abstract class ClassBodyCodegen { try { genNamedFunction((JetNamedFunction) declaration, functionCodegen); } - catch(CompilationException e) { + catch (CompilationException e) { throw e; - } catch (RuntimeException e) { + } + catch (RuntimeException e) { throw new RuntimeException("Error generating method " + myClass.getName() + "." + declaration.getName() + " in " + context, e); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CompilationErrorHandler.java b/compiler/backend/src/org/jetbrains/jet/codegen/CompilationErrorHandler.java index ccd782a7c12..a3b2acf3846 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CompilationErrorHandler.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CompilationErrorHandler.java @@ -24,6 +24,9 @@ public interface CompilationErrorHandler { CompilationErrorHandler THROW_EXCEPTION = new CompilationErrorHandler() { @Override public void reportException(Throwable exception, String fileUrl) { + if (exception instanceof RuntimeException) { + throw (RuntimeException)exception; + } throw new IllegalStateException(exception); } }; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CompilationException.java b/compiler/backend/src/org/jetbrains/jet/codegen/CompilationException.java index 017b499e327..f60a56148b9 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CompilationException.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CompilationException.java @@ -16,50 +16,29 @@ package org.jetbrains.jet.codegen; -import com.intellij.openapi.editor.Document; -import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; /** * @author alex.tkachman +* @author abreslav */ public class CompilationException extends RuntimeException { - private PsiElement element; + private final PsiElement element; - CompilationException(String message, Throwable cause, PsiElement element) { + CompilationException(@NotNull String message, @Nullable Throwable cause, @NotNull PsiElement element) { super(message, cause); this.element = element; } + @NotNull public PsiElement getElement() { return element; } - @Override - public String toString() { - PsiFile psiFile = element.getContainingFile(); - TextRange textRange = element.getTextRange(); - Document document = psiFile.getViewProvider().getDocument(); - int line; - int col; - if (document != null) { - line = document.getLineNumber(textRange.getStartOffset()); - col = textRange.getStartOffset() - document.getLineStartOffset(line) + 1; - } - else { - line = -1; - col = -1; - } - String s2 = ""; - Throwable cause = getCause(); - if (cause != null) { - s2 = cause.getMessage() != null ? cause.getMessage() : cause.toString(); - } - return "Internal error: (" + (line+1) + "," + col + ") " + s2 + "\n@" + where(); - } - private String where() { Throwable cause = getCause(); Throwable throwable = cause != null ? cause : this; @@ -67,13 +46,20 @@ public class CompilationException extends RuntimeException { if (stackTrace != null && stackTrace.length > 0) { return stackTrace[0].getFileName() + ":" + stackTrace[0].getLineNumber(); } - else { - return "unknown"; - } + return "unknown"; } @Override public String getMessage() { - return this.toString(); + StringBuilder message = new StringBuilder("Back-end (JVM) Internal error: ").append(super.getMessage()).append("\n"); + Throwable cause = getCause(); + if (cause != null) { + String causeMessage = cause.getMessage(); + message.append("Cause: ").append(causeMessage == null ? cause.toString() : causeMessage).append("\n"); + } + message.append("File being compiled and position: ").append(DiagnosticUtils.atLocation(element)).append("\n"); + message.append("The root cause was thrown at: ").append(where()); + + return message.toString(); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java index 33bb005af93..b536dae92bf 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java @@ -170,4 +170,8 @@ public class GenerationState { return answer.toString(); } + + public void destroy() { + injector.destroy(); + } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index 2a3338c7510..6478143b709 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -69,7 +69,8 @@ public class NamespaceCodegen { else if (declaration instanceof JetNamedFunction) { try { functionCodegen.gen((JetNamedFunction) declaration); - } catch (CompilationException e) { + } + catch (CompilationException e) { throw e; } catch (Exception e) { diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java index 30a4db600be..0d0ec20975d 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java @@ -30,21 +30,31 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import java.util.List; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForJetTypeMapper { + private final JetStandardLibrary jetStandardLibrary; + private final BindingContext bindingContext; + private final List listOfJetFile; private JetTypeMapper jetTypeMapper; + private CompilerSpecialMode compilerSpecialMode; + private ClassBuilderMode classBuilderMode; + private ClosureAnnotator closureAnnotator; public InjectorForJetTypeMapper( @NotNull JetStandardLibrary jetStandardLibrary, @NotNull BindingContext bindingContext, @NotNull List listOfJetFile ) { + this.jetStandardLibrary = jetStandardLibrary; + this.bindingContext = bindingContext; + this.listOfJetFile = listOfJetFile; this.jetTypeMapper = new JetTypeMapper(); - CompilerSpecialMode compilerSpecialMode = CompilerSpecialMode.REGULAR; - ClassBuilderMode classBuilderMode = ClassBuilderMode.FULL; - ClosureAnnotator closureAnnotator = new ClosureAnnotator(); + this.compilerSpecialMode = CompilerSpecialMode.REGULAR; + this.classBuilderMode = ClassBuilderMode.FULL; + this.closureAnnotator = new ClosureAnnotator(); this.jetTypeMapper.setBindingContext(bindingContext); this.jetTypeMapper.setClassBuilderMode(classBuilderMode); @@ -61,6 +71,10 @@ public class InjectorForJetTypeMapper { } + @PreDestroy + public void destroy() { + } + public JetTypeMapper getJetTypeMapper() { return this.jetTypeMapper; } diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java index e54bef57e52..b5987e16532 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java @@ -40,15 +40,23 @@ import org.jetbrains.jet.codegen.ClassBuilderMode; import org.jetbrains.jet.codegen.GenerationState; import org.jetbrains.jet.codegen.ClassBuilderFactory; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForJvmCodegen { private final JetStandardLibrary jetStandardLibrary; + private final BindingContext bindingContext; + private final List listOfJetFile; + private final Project project; + private final CompilerSpecialMode compilerSpecialMode; + private final ClassBuilderMode classBuilderMode; private final GenerationState generationState; + private final ClassBuilderFactory classBuilderFactory; private JetTypeMapper jetTypeMapper; private IntrinsicMethods intrinsics; private ClassFileFactory classFileFactory; + private ClosureAnnotator closureAnnotator; public InjectorForJvmCodegen( @NotNull JetStandardLibrary jetStandardLibrary, @@ -61,11 +69,17 @@ public class InjectorForJvmCodegen { @NotNull ClassBuilderFactory classBuilderFactory ) { this.jetStandardLibrary = jetStandardLibrary; + this.bindingContext = bindingContext; + this.listOfJetFile = listOfJetFile; + this.project = project; + this.compilerSpecialMode = compilerSpecialMode; + this.classBuilderMode = classBuilderMode; this.generationState = generationState; + this.classBuilderFactory = classBuilderFactory; this.jetTypeMapper = new JetTypeMapper(); this.intrinsics = new IntrinsicMethods(); this.classFileFactory = new ClassFileFactory(); - ClosureAnnotator closureAnnotator = new ClosureAnnotator(); + this.closureAnnotator = new ClosureAnnotator(); this.jetTypeMapper.setBindingContext(bindingContext); this.jetTypeMapper.setClassBuilderMode(classBuilderMode); @@ -90,6 +104,10 @@ public class InjectorForJvmCodegen { } + @PreDestroy + public void destroy() { + } + public JetStandardLibrary getJetStandardLibrary() { return this.jetStandardLibrary; } diff --git a/compiler/cli/bin/kotlinc b/compiler/cli/bin/kotlinc index 78cde18cb55..22858259c8b 100644 --- a/compiler/cli/bin/kotlinc +++ b/compiler/cli/bin/kotlinc @@ -95,4 +95,4 @@ CPSELECT="-cp " $JAVA_OPTS \ "${java_args[@]}" \ ${CPSELECT}${TOOL_CLASSPATH} \ - org.jetbrains.jet.cli.KotlinCompiler "$@" + org.jetbrains.jet.cli.jvm.K2JVMCompiler "$@" diff --git a/compiler/cli/bin/kotlinc.bat b/compiler/cli/bin/kotlinc.bat index 4fb6990f3b9..803309766f0 100644 --- a/compiler/cli/bin/kotlinc.bat +++ b/compiler/cli/bin/kotlinc.bat @@ -27,7 +27,7 @@ if "%_TOOL_CLASSPATH%"=="" ( for /d %%f in ("%_KOTLIN_HOME%\lib\*") do call :add_cpath "%%f" ) -"%_JAVACMD%" %_JAVA_OPTS% -cp "%_TOOL_CLASSPATH%" org.jetbrains.jet.cli.KotlinCompiler %* +"%_JAVACMD%" %_JAVA_OPTS% -cp "%_TOOL_CLASSPATH%" org.jetbrains.jet.cli.jvm.K2JVMCompiler %* goto end rem ########################################################################## diff --git a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java deleted file mode 100644 index 54a6eef6608..00000000000 --- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java +++ /dev/null @@ -1,296 +0,0 @@ -/* - * 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.cli; - -import com.google.common.base.Splitter; -import com.google.common.collect.Iterables; -import com.google.common.collect.LinkedHashMultimap; -import com.google.common.collect.Multimap; -import com.intellij.openapi.Disposable; -import com.intellij.openapi.util.Disposer; -import com.sampullara.cli.Args; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.compiler.*; -import org.jetbrains.jet.compiler.messages.CompilerMessageLocation; -import org.jetbrains.jet.compiler.messages.CompilerMessageSeverity; -import org.jetbrains.jet.compiler.messages.MessageCollector; -import org.jetbrains.jet.compiler.messages.MessageRenderer; -import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; -import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; -import org.jetbrains.jet.utils.PathUtil; - -import java.io.File; -import java.io.PrintStream; -import java.util.Collection; -import java.util.List; - -import static org.jetbrains.jet.cli.KotlinCompiler.ExitCode.*; - -/** - * @author yole - * @author alex.tkachman - */ -@SuppressWarnings("UseOfSystemOutOrSystemErr") -public class KotlinCompiler { - - public enum ExitCode { - OK(0), - COMPILATION_ERROR(1), - INTERNAL_ERROR(2); - - private final int code; - - private ExitCode(int code) { - this.code = code; - } - - public int getCode() { - return code; - } - } - - public static void main(String... args) { - doMain(new KotlinCompiler(), args); - } - - /** - * Useful main for derived command line tools - */ - public static void doMain(KotlinCompiler compiler, String[] args) { - try { - ExitCode rc = compiler.exec(System.out, args); - if (rc != OK) { - System.err.println("exec() finished with " + rc + " return code"); - System.exit(rc.getCode()); - } - } catch (CompileEnvironmentException e) { - System.err.println(e.getMessage()); - System.exit(INTERNAL_ERROR.getCode()); - } - } - - public ExitCode exec(PrintStream errStream, String... args) { - CompilerArguments arguments = createArguments(); - if (!parseArguments(errStream, arguments, args)) { - return INTERNAL_ERROR; - } - return exec(errStream, arguments); - } - - /** - * Executes the compiler on the parsed arguments - */ - public ExitCode exec(final PrintStream errStream, CompilerArguments arguments) { - if (arguments.help) { - usage(errStream); - return OK; - } - System.setProperty("java.awt.headless", "true"); - - final MessageRenderer messageRenderer = arguments.tags ? MessageRenderer.TAGS : MessageRenderer.PLAIN; - - if (arguments.version) { - errStream.println(messageRenderer.render(CompilerMessageSeverity.INFO, "Kotlin Compiler version " + CompilerVersion.VERSION, CompilerMessageLocation.NO_LOCATION)); - } - - CompilerSpecialMode mode = parseCompilerSpecialMode(arguments); - - File jdkHeadersJar; - if (mode.includeJdkHeaders()) { - if (arguments.jdkHeaders != null) { - jdkHeadersJar = new File(arguments.jdkHeaders); - } - else { - jdkHeadersJar = PathUtil.getAltHeadersPath(); - } - } - else { - jdkHeadersJar = null; - } - File runtimeJar; - - if (mode.includeKotlinRuntime()) { - if (arguments.stdlib != null) { - runtimeJar = new File(arguments.stdlib); - } - else { - runtimeJar = PathUtil.getDefaultRuntimePath(); - } - } - else { - runtimeJar = null; - } - - CompilerDependencies dependencies = new CompilerDependencies(mode, jdkHeadersJar, runtimeJar); - PrintingMessageCollector messageCollector = new PrintingMessageCollector(errStream, messageRenderer, arguments.verbose); - Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable(); - - JetCoreEnvironment environment = new JetCoreEnvironment(rootDisposable, dependencies); - CompileEnvironmentConfiguration configuration = new CompileEnvironmentConfiguration(environment, dependencies, messageCollector); - try { - configureEnvironment(configuration, arguments); - - boolean noErrors; - if (arguments.module != null) { - noErrors = KotlinToJVMBytecodeCompiler.compileModuleScript(configuration, - arguments.module, arguments.jar, arguments.outputDir, - arguments.includeRuntime); - } - else { - // TODO ideally we'd unify to just having a single field that supports multiple files/dirs - if (arguments.getSourceDirs() != null) { - noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSourceDirectories(configuration, - arguments.getSourceDirs(), arguments.jar, arguments.outputDir, arguments.includeRuntime); - } - else { - noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSources(configuration, - arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime); - } - } - return noErrors ? OK : COMPILATION_ERROR; - } - catch (Throwable t) { - errStream.println(messageRenderer.renderException(t)); - return INTERNAL_ERROR; - } - finally { - Disposer.dispose(rootDisposable); - messageCollector.printToErrStream(); - } - } - - @NotNull - private CompilerSpecialMode parseCompilerSpecialMode(@NotNull CompilerArguments arguments) { - if (arguments.mode == null) { - return CompilerSpecialMode.REGULAR; - } - else { - for (CompilerSpecialMode variant : CompilerSpecialMode.values()) { - if (arguments.mode.equalsIgnoreCase(variant.name().replaceAll("_", ""))) { - return variant; - } - } - } - // TODO: report properly - throw new IllegalArgumentException("unknown compiler mode: " + arguments.mode); - } - - /** - * Returns true if the arguments can be parsed correctly - */ - protected boolean parseArguments(PrintStream errStream, CompilerArguments arguments, String[] args) { - try { - Args.parse(arguments, args); - return true; - } - catch (IllegalArgumentException e) { - usage(errStream); - } - catch (Throwable t) { - // Always use tags - errStream.println(MessageRenderer.TAGS.renderException(t)); - } - return false; - } - - protected void usage(PrintStream target) { - // We should say something like - // Args.usage(target, CompilerArguments.class); - // but currently cli-parser we are using does not support that - // a corresponding patch has been sent to the authors - // For now, we are using this: - - PrintStream oldErr = System.err; - System.setErr(target); - try { - // TODO: use proper argv0 - Args.usage(new CompilerArguments()); - } finally { - System.setErr(oldErr); - } - } - - /** - * Allow derived classes to add additional command line arguments - */ - protected CompilerArguments createArguments() { - return new CompilerArguments(); - } - - /** - * Strategy method to configure the environment, allowing compiler - * based tools to customise their own plugins - */ - protected void configureEnvironment(CompileEnvironmentConfiguration configuration, CompilerArguments arguments) { - // install any compiler plugins - List plugins = arguments.getCompilerPlugins(); - if (plugins != null) { - configuration.getCompilerPlugins().addAll(plugins); - } - - if (configuration.getCompilerDependencies().getRuntimeJar() != null) { - CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar()); - } - - if (arguments.classpath != null) { - final Iterable classpath = Splitter.on(File.pathSeparatorChar).split(arguments.classpath); - CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), Iterables.toArray(classpath, String.class)); - } - } - - private static class PrintingMessageCollector implements MessageCollector { - private final boolean verbose; - private final PrintStream errStream; - private final MessageRenderer messageRenderer; - - // File path (nullable) -> error message - private final Multimap groupedMessages = LinkedHashMultimap.create(); - - public PrintingMessageCollector(PrintStream errStream, - MessageRenderer messageRenderer, - boolean verbose) { - this.verbose = verbose; - this.errStream = errStream; - this.messageRenderer = messageRenderer; - } - - @Override - public void report(@NotNull CompilerMessageSeverity severity, - @NotNull String message, - @NotNull CompilerMessageLocation location) { - String text = messageRenderer.render(severity, message, location); - if (severity == CompilerMessageSeverity.LOGGING) { - if (!verbose) { - return; - } - errStream.println(text); - } - groupedMessages.put(location.getPath(), text); - } - - public void printToErrStream() { - if (!groupedMessages.isEmpty()) { - for (String path : groupedMessages.keySet()) { - Collection messageTexts = groupedMessages.get(path); - for (String text : messageTexts) { - errStream.println(text); - } - } - } - } - } -} diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompilerPlugin.java b/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPlugin.java similarity index 95% rename from compiler/cli/src/org/jetbrains/jet/compiler/CompilerPlugin.java rename to compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPlugin.java index bc2db80c71e..8587929d80c 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompilerPlugin.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPlugin.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.common; /** * A simple interface for compiler plugins to run after the compiler has finished such as for things like diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompilerPluginContext.java b/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java similarity index 97% rename from compiler/cli/src/org/jetbrains/jet/compiler/CompilerPluginContext.java rename to compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java index 8ce1d7ef805..7716e3130ed 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompilerPluginContext.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.common; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.psi.JetFile; diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/ExitCode.java b/compiler/cli/src/org/jetbrains/jet/cli/common/ExitCode.java new file mode 100644 index 00000000000..db3c954d0db --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/ExitCode.java @@ -0,0 +1,36 @@ +/* + * 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.cli.common; + +/** +* @author Pavel Talanov +*/ +public enum ExitCode { + OK(0), + COMPILATION_ERROR(1), + INTERNAL_ERROR(2); + + private final int code; + + ExitCode(int code) { + this.code = code; + } + + public int getCode() { + return code; + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java new file mode 100644 index 00000000000..24c2f1b1175 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java @@ -0,0 +1,151 @@ +/* + * 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.cli.common.messages; + +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.PsiErrorElement; +import com.intellij.psi.PsiRecursiveElementWalkingVisitor; +import jet.Function0; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.diagnostics.*; +import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; + +import java.util.Collection; + +/** + * @author Pavel Talanov + */ +public final class AnalyzerWithCompilerReport { + + @NotNull + private static CompilerMessageSeverity convertSeverity(@NotNull Severity severity) { + switch (severity) { + case INFO: + return CompilerMessageSeverity.INFO; + case ERROR: + return CompilerMessageSeverity.ERROR; + case WARNING: + return CompilerMessageSeverity.WARNING; + } + throw new IllegalStateException("Unknown severity: " + severity); + } + + @NotNull + private static final SimpleDiagnosticFactory SYNTAX_ERROR_FACTORY = SimpleDiagnosticFactory.create(Severity.ERROR); + + private boolean hasErrors = false; + @NotNull + private final MessageCollector messageCollectorWrapper; + @Nullable + private AnalyzeExhaust analyzeExhaust = null; + + public AnalyzerWithCompilerReport(@NotNull final MessageCollector collector) { + messageCollectorWrapper = new MessageCollector() { + @Override + public void report(@NotNull CompilerMessageSeverity severity, + @NotNull String message, + @NotNull CompilerMessageLocation location) { + if (CompilerMessageSeverity.ERRORS.contains(severity)) { + hasErrors = true; + } + collector.report(severity, message, location); + } + }; + } + + private void reportDiagnostic(@NotNull Diagnostic diagnostic) { + DiagnosticUtils.LineAndColumn lineAndColumn = DiagnosticUtils.getLineAndColumn(diagnostic); + VirtualFile virtualFile = diagnostic.getPsiFile().getVirtualFile(); + String path = virtualFile == null ? null : virtualFile.getPath(); + String render; + if (diagnostic.getFactory() == SYNTAX_ERROR_FACTORY) { + render = ((SyntaxErrorDiagnostic)diagnostic).message; + } + else { + render = DefaultErrorMessages.RENDERER.render(diagnostic); + } + messageCollectorWrapper.report(convertSeverity(diagnostic.getSeverity()), render, + CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn())); + } + + private void reportIncompleteHierarchies() { + assert analyzeExhaust != null; + Collection incompletes = analyzeExhaust.getBindingContext().getKeys(BindingContext.INCOMPLETE_HIERARCHY); + if (!incompletes.isEmpty()) { + StringBuilder message = new StringBuilder("The following classes have incomplete hierarchies:\n"); + for (ClassDescriptor incomplete : incompletes) { + String fqName = DescriptorUtils.getFQName(incomplete).getFqName(); + message.append(" ").append(fqName).append("\n"); + } + messageCollectorWrapper.report(CompilerMessageSeverity.ERROR, message.toString(), CompilerMessageLocation.NO_LOCATION); + } + } + + private void reportDiagnostics() { + assert analyzeExhaust != null; + for (Diagnostic diagnostic : analyzeExhaust.getBindingContext().getDiagnostics()) { + reportDiagnostic(diagnostic); + } + } + + private void reportSyntaxErrors(@NotNull Collection files) { + for (JetFile file : files) { + file.accept(new PsiRecursiveElementWalkingVisitor() { + @Override + public void visitErrorElement(PsiErrorElement element) { + String description = element.getErrorDescription(); + String message = StringUtil.isEmpty(description) ? "Syntax error" : description; + Diagnostic diagnostic = new SyntaxErrorDiagnostic(element, Severity.ERROR, message); + reportDiagnostic(diagnostic); + } + }); + } + } + + @Nullable + public AnalyzeExhaust getAnalyzeExhaust() { + return analyzeExhaust; + } + + public boolean hasErrors() { + return hasErrors; + } + + public void analyzeAndReport(@NotNull Function0 analyzer, @NotNull Collection files) { + reportSyntaxErrors(files); + analyzeExhaust = analyzer.invoke(); + reportDiagnostics(); + reportIncompleteHierarchies(); + } + + + public static class SyntaxErrorDiagnostic extends SimpleDiagnostic { + private String message; + + public SyntaxErrorDiagnostic(@NotNull PsiErrorElement psiElement, @NotNull Severity severity, String message) { + super(psiElement, SYNTAX_ERROR_FACTORY, severity); + this.message = message; + } + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/messages/CompilerMessageLocation.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/CompilerMessageLocation.java similarity index 96% rename from compiler/cli/src/org/jetbrains/jet/compiler/messages/CompilerMessageLocation.java rename to compiler/cli/src/org/jetbrains/jet/cli/common/messages/CompilerMessageLocation.java index f39e6c43a4e..247656bc88b 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/messages/CompilerMessageLocation.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/CompilerMessageLocation.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler.messages; +package org.jetbrains.jet.cli.common.messages; import org.jetbrains.annotations.Nullable; diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/messages/CompilerMessageSeverity.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/CompilerMessageSeverity.java similarity index 94% rename from compiler/cli/src/org/jetbrains/jet/compiler/messages/CompilerMessageSeverity.java rename to compiler/cli/src/org/jetbrains/jet/cli/common/messages/CompilerMessageSeverity.java index 9171be05403..2608639a9f6 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/messages/CompilerMessageSeverity.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/CompilerMessageSeverity.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler.messages; +package org.jetbrains.jet.cli.common.messages; import java.util.EnumSet; diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/messages/MessageCollector.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageCollector.java similarity index 96% rename from compiler/cli/src/org/jetbrains/jet/compiler/messages/MessageCollector.java rename to compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageCollector.java index 5fb1b0973a0..44b2697262b 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/messages/MessageCollector.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageCollector.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler.messages; +package org.jetbrains.jet.cli.common.messages; import org.jetbrains.annotations.NotNull; diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/messages/MessageRenderer.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageRenderer.java similarity index 77% rename from compiler/cli/src/org/jetbrains/jet/compiler/messages/MessageRenderer.java rename to compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageRenderer.java index acf7ec08e21..15eb3824455 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/messages/MessageRenderer.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageRenderer.java @@ -14,8 +14,9 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler.messages; +package org.jetbrains.jet.cli.common.messages; +import com.intellij.openapi.util.text.StringUtil; import org.jetbrains.annotations.NotNull; import java.io.PrintWriter; @@ -27,30 +28,49 @@ import java.io.StringWriter; public interface MessageRenderer { MessageRenderer TAGS = new MessageRenderer() { + @Override + public String renderPreamble() { + return ""; + } + @Override public String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) { StringBuilder out = new StringBuilder(); out.append("<").append(severity.toString()); if (location.getPath() != null) { - out.append(" path=\"").append(location.getPath()).append("\""); + out.append(" path=\"").append(e(location.getPath())).append("\""); out.append(" line=\"").append(location.getLine()).append("\""); out.append(" column=\"").append(location.getColumn()).append("\""); } out.append(">\n"); - out.append(message); + out.append(e(message)); out.append("\n"); return out.toString(); } + private String e(String str) { + return StringUtil.escapeXml(str); + } + @Override public String renderException(@NotNull Throwable e) { return render(CompilerMessageSeverity.EXCEPTION, PLAIN.renderException(e), CompilerMessageLocation.NO_LOCATION); } + + @Override + public String renderConclusion() { + return ""; + } }; MessageRenderer PLAIN = new MessageRenderer() { + @Override + public String renderPreamble() { + return ""; + } + @Override public String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) { String path = location.getPath(); @@ -65,8 +85,15 @@ public interface MessageRenderer { e.printStackTrace(new PrintWriter(out)); return out.toString(); } + + @Override + public String renderConclusion() { + return ""; + } }; + String renderPreamble(); String render(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location); String renderException(@NotNull Throwable e); + String renderConclusion(); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageUtil.java new file mode 100644 index 00000000000..9e3775e3ef4 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageUtil.java @@ -0,0 +1,32 @@ +/* + * 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.cli.common.messages; + +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; + +/** + * @author abreslav + */ +public class MessageUtil { + public static CompilerMessageLocation psiElementToMessageLocation(PsiElement element) { + PsiFile file = element.getContainingFile(); + DiagnosticUtils.LineAndColumn lineAndColumn = DiagnosticUtils.getLineAndColumnInPsiFile(file, element.getTextRange()); + return CompilerMessageLocation.create(file.getVirtualFile().getPath(), lineAndColumn.getLine(), lineAndColumn.getColumn()); + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java new file mode 100644 index 00000000000..9f9e8b0120d --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/PrintingMessageCollector.java @@ -0,0 +1,73 @@ +/* + * 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.cli.common.messages; + +import com.google.common.collect.LinkedHashMultimap; +import com.google.common.collect.Multimap; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation; +import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity; +import org.jetbrains.jet.cli.common.messages.MessageCollector; +import org.jetbrains.jet.cli.common.messages.MessageRenderer; + +import java.io.PrintStream; +import java.util.Collection; + +/** + * @author Pavel Talanov + */ +public class PrintingMessageCollector implements MessageCollector { + private final boolean verbose; + private final PrintStream errStream; + private final MessageRenderer messageRenderer; + + // File path (nullable) -> error message + private final Multimap groupedMessages = LinkedHashMultimap.create(); + + public PrintingMessageCollector(PrintStream errStream, + MessageRenderer messageRenderer, + boolean verbose) { + this.verbose = verbose; + this.errStream = errStream; + this.messageRenderer = messageRenderer; + } + + @Override + public void report(@NotNull CompilerMessageSeverity severity, + @NotNull String message, + @NotNull CompilerMessageLocation location) { + String text = messageRenderer.render(severity, message, location); + if (severity == CompilerMessageSeverity.LOGGING) { + if (!verbose) { + return; + } + errStream.println(text); + } + groupedMessages.put(location.getPath(), text); + } + + public void printToErrStream() { + if (!groupedMessages.isEmpty()) { + for (String path : groupedMessages.keySet()) { + Collection messageTexts = groupedMessages.get(path); + for (String text : messageTexts) { + errStream.println(text); + } + } + } + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java new file mode 100644 index 00000000000..63d8e8fb778 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java @@ -0,0 +1,27 @@ +/* + * 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.cli.js; + +/** + * @author Pavel Talanov + */ +public final class K2JSCompiler { + + public static void main(String... args) { + //TODO + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java new file mode 100644 index 00000000000..46522696f05 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java @@ -0,0 +1,24 @@ +/* + * 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.cli.js; + +/** + * @author Pavel Talanov + */ +//TODO +public class K2JSCompilerArguments { +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java new file mode 100644 index 00000000000..007253e25e5 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java @@ -0,0 +1,255 @@ +/* + * 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.cli.jvm; + +import com.google.common.base.Splitter; +import com.google.common.collect.Iterables; +import com.intellij.openapi.Disposable; +import com.intellij.openapi.util.Disposer; +import com.sampullara.cli.Args; +import jet.modules.Module; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.cli.common.CompilerPlugin; +import org.jetbrains.jet.cli.common.ExitCode; +import org.jetbrains.jet.cli.common.messages.PrintingMessageCollector; +import org.jetbrains.jet.codegen.CompilationException; +import org.jetbrains.jet.cli.jvm.compiler.*; +import org.jetbrains.jet.cli.common.messages.*; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; +import org.jetbrains.jet.utils.PathUtil; + +import java.io.File; +import java.io.PrintStream; +import java.util.List; + +import static org.jetbrains.jet.cli.common.ExitCode.*; + +/** + * @author yole + * @author alex.tkachman + */ +@SuppressWarnings("UseOfSystemOutOrSystemErr") +public class K2JVMCompiler { + + public static void main(String... args) { + doMain(new K2JVMCompiler(), args); + } + + /** + * Useful main for derived command line tools + */ + public static void doMain(K2JVMCompiler compiler, String[] args) { + try { + ExitCode rc = compiler.exec(System.out, args); + if (rc != OK) { + System.err.println("exec() finished with " + rc + " return code"); + System.exit(rc.getCode()); + } + } + catch (CompileEnvironmentException e) { + System.err.println(e.getMessage()); + System.exit(INTERNAL_ERROR.getCode()); + } + } + + public ExitCode exec(PrintStream errStream, String... args) { + K2JVMCompilerArguments arguments = createArguments(); + if (!parseArguments(errStream, arguments, args)) { + return INTERNAL_ERROR; + } + return exec(errStream, arguments); + } + + /** + * Executes the compiler on the parsed arguments + */ + public ExitCode exec(final PrintStream errStream, K2JVMCompilerArguments arguments) { + if (arguments.help) { + usage(errStream); + return OK; + } + System.setProperty("java.awt.headless", "true"); + + final MessageRenderer messageRenderer = arguments.tags ? MessageRenderer.TAGS : MessageRenderer.PLAIN; + + errStream.print(messageRenderer.renderPreamble()); + + try { + if (arguments.version) { + errStream.println(messageRenderer.render(CompilerMessageSeverity.INFO, "Kotlin Compiler version " + K2JVMCompilerVersion.VERSION, CompilerMessageLocation.NO_LOCATION)); + } + + CompilerSpecialMode mode = parseCompilerSpecialMode(arguments); + + File jdkHeadersJar; + if (mode.includeJdkHeaders()) { + if (arguments.jdkHeaders != null) { + jdkHeadersJar = new File(arguments.jdkHeaders); + } + else { + jdkHeadersJar = PathUtil.getAltHeadersPath(); + } + } + else { + jdkHeadersJar = null; + } + File runtimeJar; + + if (mode.includeKotlinRuntime()) { + if (arguments.stdlib != null) { + runtimeJar = new File(arguments.stdlib); + } + else { + runtimeJar = PathUtil.getDefaultRuntimePath(); + } + } + else { + runtimeJar = null; + } + + CompilerDependencies dependencies = new CompilerDependencies(mode, CompilerDependencies.findRtJar(), jdkHeadersJar, runtimeJar); + PrintingMessageCollector messageCollector = new PrintingMessageCollector(errStream, messageRenderer, arguments.verbose); + Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable(); + + JetCoreEnvironment environment = new JetCoreEnvironment(rootDisposable, dependencies); + CompileEnvironmentConfiguration configuration = new CompileEnvironmentConfiguration(environment, dependencies, messageCollector); + + messageCollector.report(CompilerMessageSeverity.LOGGING, "Configuring the compilation environment", + CompilerMessageLocation.NO_LOCATION); + try { + configureEnvironment(configuration, arguments); + + boolean noErrors; + if (arguments.module != null) { + List modules = CompileEnvironmentUtil.loadModuleScript(arguments.module, new PrintingMessageCollector(errStream, messageRenderer, false)); + File directory = new File(arguments.module).getParentFile(); + noErrors = KotlinToJVMBytecodeCompiler.compileModules(configuration, modules, + directory, arguments.jar, arguments.outputDir, + arguments.includeRuntime); + } + else { + // TODO ideally we'd unify to just having a single field that supports multiple files/dirs + if (arguments.getSourceDirs() != null) { + noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSourceDirectories(configuration, + arguments.getSourceDirs(), arguments.jar, arguments.outputDir, arguments.includeRuntime); + } + else { + noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSources(configuration, + arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime); + } + } + return noErrors ? OK : COMPILATION_ERROR; + } + catch (CompilationException e) { + messageCollector.report(CompilerMessageSeverity.EXCEPTION, MessageRenderer.PLAIN.renderException(e), + MessageUtil.psiElementToMessageLocation(e.getElement())); + return INTERNAL_ERROR; + } + catch (Throwable t) { + messageCollector.report(CompilerMessageSeverity.EXCEPTION, MessageRenderer.PLAIN.renderException(t), CompilerMessageLocation.NO_LOCATION); + return INTERNAL_ERROR; + } + finally { + Disposer.dispose(rootDisposable); + messageCollector.printToErrStream(); + } + } + finally { + errStream.print(messageRenderer.renderConclusion()); + } + } + + @NotNull + private CompilerSpecialMode parseCompilerSpecialMode(@NotNull K2JVMCompilerArguments arguments) { + if (arguments.mode == null) { + return CompilerSpecialMode.REGULAR; + } + else { + for (CompilerSpecialMode variant : CompilerSpecialMode.values()) { + if (arguments.mode.equalsIgnoreCase(variant.name().replaceAll("_", ""))) { + return variant; + } + } + } + // TODO: report properly + throw new IllegalArgumentException("unknown compiler mode: " + arguments.mode); + } + + /** + * Returns true if the arguments can be parsed correctly + */ + protected boolean parseArguments(PrintStream errStream, K2JVMCompilerArguments arguments, String[] args) { + try { + Args.parse(arguments, args); + return true; + } + catch (IllegalArgumentException e) { + usage(errStream); + } + catch (Throwable t) { + // Always use tags + errStream.println(MessageRenderer.TAGS.renderException(t)); + } + return false; + } + + protected void usage(PrintStream target) { + // We should say something like + // Args.usage(target, K2JVMCompilerArguments.class); + // but currently cli-parser we are using does not support that + // a corresponding patch has been sent to the authors + // For now, we are using this: + + PrintStream oldErr = System.err; + System.setErr(target); + try { + // TODO: use proper argv0 + Args.usage(new K2JVMCompilerArguments()); + } finally { + System.setErr(oldErr); + } + } + + /** + * Allow derived classes to add additional command line arguments + */ + protected K2JVMCompilerArguments createArguments() { + return new K2JVMCompilerArguments(); + } + + /** + * Strategy method to configure the environment, allowing compiler + * based tools to customise their own plugins + */ + protected void configureEnvironment(CompileEnvironmentConfiguration configuration, K2JVMCompilerArguments arguments) { + // install any compiler plugins + List plugins = arguments.getCompilerPlugins(); + if (plugins != null) { + configuration.getCompilerPlugins().addAll(plugins); + } + + if (configuration.getCompilerDependencies().getRuntimeJar() != null) { + CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar()); + } + + if (arguments.classpath != null) { + final Iterable classpath = Splitter.on(File.pathSeparatorChar).split(arguments.classpath); + CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), Iterables.toArray(classpath, String.class)); + } + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerArguments.java similarity index 95% rename from compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerArguments.java index ee233809581..bed558b5f08 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/CompilerArguments.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerArguments.java @@ -15,18 +15,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jetbrains.jet.cli; +package org.jetbrains.jet.cli.jvm; import com.sampullara.cli.Argument; -import org.jetbrains.jet.compiler.CompilerPlugin; +import org.jetbrains.jet.cli.common.CompilerPlugin; import java.util.ArrayList; import java.util.List; /** - * Command line arguments for the {@link KotlinCompiler} + * Command line arguments for the {@link K2JVMCompiler} */ -public class CompilerArguments { +public class K2JVMCompilerArguments { private List compilerPlugins = new ArrayList(); // TODO ideally we'd unify this with 'src' to just having a single field that supports multiple files/dirs @@ -157,7 +157,7 @@ public class CompilerArguments { } /** - * Sets the compiler plugins to be used when working with the {@link KotlinCompiler} + * Sets the compiler plugins to be used when working with the {@link K2JVMCompiler} */ public void setCompilerPlugins(List compilerPlugins) { this.compilerPlugins = compilerPlugins; diff --git a/compiler/cli/src/org/jetbrains/jet/cli/CompilerVersion.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerVersion.java similarity index 91% rename from compiler/cli/src/org/jetbrains/jet/cli/CompilerVersion.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerVersion.java index 674ba94041d..460d5c89493 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/CompilerVersion.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerVersion.java @@ -14,12 +14,12 @@ * limitations under the License. */ -package org.jetbrains.jet.cli; +package org.jetbrains.jet.cli.jvm; /** * @author abreslav */ -public class CompilerVersion { +public class K2JVMCompilerVersion { // The value of this constant is generated by the build script // DON'T MODIFY IT public static final String VERSION = "@snapshot@"; diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CliJetFilesProvider.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliJetFilesProvider.java similarity index 97% rename from compiler/cli/src/org/jetbrains/jet/compiler/CliJetFilesProvider.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliJetFilesProvider.java index a5e95ae5696..fa66c13bcaa 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CliJetFilesProvider.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliJetFilesProvider.java @@ -17,7 +17,7 @@ /* * @author max */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.util.Function; diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentConfiguration.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentConfiguration.java similarity index 92% rename from compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentConfiguration.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentConfiguration.java index cf57bee50b2..e95f3ba7186 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentConfiguration.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentConfiguration.java @@ -14,12 +14,13 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.google.common.collect.Lists; import com.intellij.openapi.util.Disposer; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.compiler.messages.MessageCollector; +import org.jetbrains.jet.cli.common.CompilerPlugin; +import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import java.util.List; diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentException.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentException.java similarity index 95% rename from compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentException.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentException.java index bf9d8e58c05..92ef9b972d7 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentException.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentException.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; /** * @author yole diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentUtil.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java similarity index 90% rename from compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentUtil.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java index ca803c0549f..344fa99cd59 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/CompileEnvironmentUtil.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.openapi.Disposable; import com.intellij.openapi.util.Disposer; @@ -25,10 +25,10 @@ import com.intellij.util.Processor; import jet.modules.AllModules; import jet.modules.Module; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GeneratedClassLoader; import org.jetbrains.jet.codegen.GenerationState; -import org.jetbrains.jet.compiler.messages.MessageCollector; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; @@ -78,10 +78,6 @@ public class CompileEnvironmentUtil { return null; } - //public static void ensureRuntime(@NotNull JetCoreEnvironment env) { - // ensureJdkRuntime(env); - //} - public static void ensureKotlinRuntime(JetCoreEnvironment env) { if (JavaPsiFacade.getInstance(env.getProject()).findClass("jet.JetObject", GlobalSearchScope.allScope(env.getProject())) == null) { // TODO: prepend @@ -97,8 +93,10 @@ public class CompileEnvironmentUtil { } } + public static void ensureJdkRuntime(JetCoreEnvironment env) { - if (JavaPsiFacade.getInstance(env.getProject()).findClass("java.lang.Object", GlobalSearchScope.allScope(env.getProject())) == null) { + if (JavaPsiFacade.getInstance(env.getProject()).findClass("java.lang.Object", GlobalSearchScope.allScope(env.getProject())) == + null) { // TODO: prepend env.addToClasspath(findRtJar()); } @@ -151,16 +149,7 @@ public class CompileEnvironmentUtil { } } - //private CompileEnvironment copyEnvironment(boolean verbose) { - // CompileEnvironment compileEnvironment = new CompileEnvironment(messageRenderer, verbose, compilerDependencies); - // compileEnvironment.setIgnoreErrors(ignoreErrors); - // compileEnvironment.setErrorStream(errorStream); - // // copy across any compiler plugins - // compileEnvironment.getEnvironment().getCompilerPlugins().addAll(environment.getCompilerPlugins()); - // return compileEnvironment; - //} - // - public static List loadModuleScript(String moduleFile, MessageCollector messageCollector) { + public static List loadModuleScript(String moduleScriptFile, MessageCollector messageCollector) { Disposable disposable = new Disposable() { @Override public void dispose() { @@ -170,7 +159,7 @@ public class CompileEnvironmentUtil { CompilerDependencies dependencies = CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR); JetCoreEnvironment scriptEnvironment = new JetCoreEnvironment(disposable, dependencies); ensureRuntime(scriptEnvironment, dependencies); - scriptEnvironment.addSources(moduleFile); + scriptEnvironment.addSources(moduleScriptFile); GenerationState generationState = KotlinToJVMBytecodeCompiler .analyzeAndGenerate(new CompileEnvironmentConfiguration(scriptEnvironment, dependencies, messageCollector), false); @@ -178,9 +167,17 @@ public class CompileEnvironmentUtil { return null; } - List modules = runDefineModules(dependencies, moduleFile, generationState.getFactory()); + List modules = runDefineModules(dependencies, moduleScriptFile, generationState.getFactory()); Disposer.dispose(disposable); + + if (modules == null) { + throw new CompileEnvironmentException("Module script " + moduleScriptFile + " compilation failed"); + } + + if (modules.isEmpty()) { + throw new CompileEnvironmentException("No modules where defined by " + moduleScriptFile); + } return modules; } @@ -189,8 +186,10 @@ public class CompileEnvironmentUtil { GeneratedClassLoader loader; if (stdlibJar != null) { try { - loader = new GeneratedClassLoader(factory, new URLClassLoader(new URL[]{stdlibJar.toURI().toURL()}, AllModules.class.getClassLoader())); - } catch (MalformedURLException e) { + loader = new GeneratedClassLoader(factory, new URLClassLoader(new URL[]{stdlibJar.toURI().toURL()}, + AllModules.class.getClassLoader())); + } + catch (MalformedURLException e) { throw new RuntimeException(e); } } @@ -242,8 +241,8 @@ public class CompileEnvironmentUtil { stream.close(); fos.close(); } - - } catch (IOException e) { + } + catch (IOException e) { throw new CompileEnvironmentException("Failed to generate jar file", e); } } @@ -288,7 +287,8 @@ public class CompileEnvironmentUtil { FileUtil.copy(jis, stream); } } - } finally { + } + finally { jis.close(); } } @@ -304,7 +304,8 @@ public class CompileEnvironmentUtil { File target = new File(outputDir, file); try { FileUtil.writeToFile(target, factory.asBytes(file)); - } catch (IOException e) { + } + catch (IOException e) { throw new CompileEnvironmentException(e); } } @@ -312,10 +313,11 @@ public class CompileEnvironmentUtil { /** * Add path specified to the compilation environment. + * * @param environment compilation environment to add to - * @param paths paths to add + * @param paths paths to add */ - public static void addToClasspath(JetCoreEnvironment environment, File ... paths) { + public static void addToClasspath(JetCoreEnvironment environment, File... paths) { for (File path : paths) { if (!path.exists()) { throw new CompileEnvironmentException("'" + path + "' does not exist"); @@ -326,10 +328,11 @@ public class CompileEnvironmentUtil { /** * Add path specified to the compilation environment. + * * @param environment compilation environment to add to - * @param paths paths to add + * @param paths paths to add */ - public static void addToClasspath(JetCoreEnvironment environment, String ... paths) { + public static void addToClasspath(JetCoreEnvironment environment, String... paths) { for (String path : paths) { addToClasspath(environment, new File(path)); } diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java similarity index 98% rename from compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java index bd8eb357ccf..14e5111f06b 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/JetCoreEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.core.JavaCoreEnvironment; import com.intellij.lang.java.JavaParserDefinition; @@ -64,6 +64,8 @@ public class JetCoreEnvironment extends JavaCoreEnvironment { CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); + addToClasspath(compilerDependencies.getJdkJar()); + if (compilerSpecialMode.includeJdkHeaders()) { for (VirtualFile root : compilerDependencies.getJdkHeaderRoots()) { addLibraryRoot(root); diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java similarity index 56% rename from compiler/cli/src/org/jetbrains/jet/compiler/KotlinToJVMBytecodeCompiler.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 7e6af64de21..af98cf42dc6 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -14,37 +14,28 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Ref; -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiErrorElement; import com.intellij.psi.PsiFile; -import com.intellij.psi.PsiRecursiveElementWalkingVisitor; import com.intellij.testFramework.LightVirtualFile; import com.intellij.util.LocalTimeCounter; +import jet.Function0; import jet.modules.Module; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.cli.common.CompilerPlugin; +import org.jetbrains.jet.cli.common.CompilerPluginContext; import org.jetbrains.jet.codegen.*; -import org.jetbrains.jet.compiler.messages.CompilerMessageLocation; -import org.jetbrains.jet.compiler.messages.CompilerMessageSeverity; -import org.jetbrains.jet.compiler.messages.MessageCollector; +import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport; +import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation; +import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory; -import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; -import org.jetbrains.jet.lang.diagnostics.Severity; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.JvmAbi; @@ -55,7 +46,6 @@ import org.jetbrains.jet.utils.Progress; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; -import java.util.Collection; import java.util.List; /** @@ -64,11 +54,14 @@ import java.util.List; */ public class KotlinToJVMBytecodeCompiler { + private KotlinToJVMBytecodeCompiler() { + } + @Nullable public static ClassFileFactory compileModule( CompileEnvironmentConfiguration configuration, Module moduleBuilder, - String directory + File directory ) { if (moduleBuilder.getSourceFiles().isEmpty()) { throw new CompileEnvironmentException("No source files where defined"); @@ -99,30 +92,23 @@ public class KotlinToJVMBytecodeCompiler { return generationState.getFactory(); } - public static boolean compileModuleScript( + public static boolean compileModules( CompileEnvironmentConfiguration configuration, - @NotNull String moduleScriptFile, + @NotNull List modules, + + @NotNull File directory, @Nullable String jarPath, @Nullable String outputDir, boolean jarRuntime) { - List modules = CompileEnvironmentUtil.loadModuleScript(moduleScriptFile, configuration.getMessageCollector()); - if (modules == null) { - throw new CompileEnvironmentException("Module script " + moduleScriptFile + " compilation failed"); - } - - if (modules.isEmpty()) { - throw new CompileEnvironmentException("No modules where defined by " + moduleScriptFile); - } - - final String directory = new File(moduleScriptFile).getParent(); for (Module moduleBuilder : modules) { // TODO: this should be done only once for the environment if (configuration.getCompilerDependencies().getRuntimeJar() != null) { - CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar()); + CompileEnvironmentUtil + .addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar()); } - ClassFileFactory moduleFactory = KotlinToJVMBytecodeCompiler.compileModule(configuration, moduleBuilder, directory); + ClassFileFactory moduleFactory = compileModule(configuration, moduleBuilder, directory); if (moduleFactory == null) { return false; } @@ -144,7 +130,6 @@ public class KotlinToJVMBytecodeCompiler { private static boolean compileBunchOfSources( CompileEnvironmentConfiguration configuration, - String jar, String outputDir, boolean includeRuntime @@ -165,21 +150,27 @@ public class KotlinToJVMBytecodeCompiler { return false; } - ClassFileFactory factory = generationState.getFactory(); - if (jar != null) { - try { - CompileEnvironmentUtil.writeToJar(factory, new FileOutputStream(jar), mainClass, includeRuntime); - } catch (FileNotFoundException e) { - throw new CompileEnvironmentException("Invalid jar path " + jar, e); + try { + ClassFileFactory factory = generationState.getFactory(); + if (jar != null) { + try { + CompileEnvironmentUtil.writeToJar(factory, new FileOutputStream(jar), mainClass, includeRuntime); + } + catch (FileNotFoundException e) { + throw new CompileEnvironmentException("Invalid jar path " + jar, e); + } } + else if (outputDir != null) { + CompileEnvironmentUtil.writeToOutputDirectory(factory, outputDir); + } + else { + throw new CompileEnvironmentException("Output directory or jar file is not specified - no files will be saved to the disk"); + } + return true; } - else if (outputDir != null) { - CompileEnvironmentUtil.writeToOutputDirectory(factory, outputDir); + finally { + generationState.destroy(); } - else { - throw new CompileEnvironmentException("Output directory or jar file is not specified - no files will be saved to the disk"); - } - return true; } public static boolean compileBunchOfSources( @@ -205,9 +196,9 @@ public class KotlinToJVMBytecodeCompiler { @Nullable public static ClassLoader compileText( CompileEnvironmentConfiguration configuration, - String code) { - configuration.getEnvironment().addSources(new LightVirtualFile("script" + LocalTimeCounter.currentTime() + ".kt", JetLanguage.INSTANCE, code)); + configuration.getEnvironment() + .addSources(new LightVirtualFile("script" + LocalTimeCounter.currentTime() + ".kt", JetLanguage.INSTANCE, code)); GenerationState generationState = analyzeAndGenerate(configuration); if (generationState == null) { @@ -224,7 +215,6 @@ public class KotlinToJVMBytecodeCompiler { @Nullable public static GenerationState analyzeAndGenerate( CompileEnvironmentConfiguration configuration, - boolean stubs ) { AnalyzeExhaust exhaust = analyze(configuration, stubs); @@ -241,59 +231,31 @@ public class KotlinToJVMBytecodeCompiler { @Nullable private static AnalyzeExhaust analyze( final CompileEnvironmentConfiguration configuration, - boolean stubs) { - final Ref hasErrors = new Ref(false); - final MessageCollector messageCollectorWrapper = new MessageCollector() { - - @Override - public void report(@NotNull CompilerMessageSeverity severity, - @NotNull String message, - @NotNull CompilerMessageLocation location) { - if (CompilerMessageSeverity.ERRORS.contains(severity)) { - hasErrors.set(true); - } - configuration.getMessageCollector().report(severity, message, location); - } - }; - - JetCoreEnvironment environment = configuration.getEnvironment(); - - // Report syntax errors - for (JetFile file : environment.getSourceFiles()) { - file.accept(new PsiRecursiveElementWalkingVisitor() { - @Override - public void visitErrorElement(PsiErrorElement element) { - String description = element.getErrorDescription(); - String message = StringUtil.isEmpty(description) ? "Syntax error" : description; - Diagnostic diagnostic = DiagnosticFactory.create(Severity.ERROR, message).on(element); - reportDiagnostic(messageCollectorWrapper, diagnostic); - } - }); - } - - // Analyze and report semantic errors - Predicate filesToAnalyzeCompletely = + final JetCoreEnvironment environment = configuration.getEnvironment(); + AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(configuration.getMessageCollector()); + final Predicate filesToAnalyzeCompletely = stubs ? Predicates.alwaysFalse() : Predicates.alwaysTrue(); - AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( - environment.getProject(), environment.getSourceFiles(), filesToAnalyzeCompletely, JetControlFlowDataTraceFactory.EMPTY, - configuration.getCompilerDependencies()); + analyzerWithCompilerReport.analyzeAndReport( + new Function0() { + @NotNull + @Override + public AnalyzeExhaust invoke() { + return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( + environment.getProject(), environment.getSourceFiles(), filesToAnalyzeCompletely, + JetControlFlowDataTraceFactory.EMPTY, + configuration.getCompilerDependencies()); + } + }, environment.getSourceFiles() + ); - for (Diagnostic diagnostic : exhaust.getBindingContext().getDiagnostics()) { - reportDiagnostic(messageCollectorWrapper, diagnostic); - } - - reportIncompleteHierarchies(messageCollectorWrapper, exhaust); - - return hasErrors.get() ? null : exhaust; + return analyzerWithCompilerReport.hasErrors() ? null : analyzerWithCompilerReport.getAnalyzeExhaust(); } @NotNull private static GenerationState generate( final CompileEnvironmentConfiguration configuration, - AnalyzeExhaust exhaust, - boolean stubs) { JetCoreEnvironment environment = configuration.getEnvironment(); Project project = environment.getProject(); @@ -304,7 +266,8 @@ public class KotlinToJVMBytecodeCompiler { } }; GenerationState generationState = new GenerationState(project, ClassBuilderFactories.binaries(stubs), backendProgress, - exhaust, environment.getSourceFiles(), configuration.getCompilerDependencies().getCompilerSpecialMode()); + exhaust, environment.getSourceFiles(), + configuration.getCompilerDependencies().getCompilerSpecialMode()); generationState.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); List plugins = configuration.getCompilerPlugins(); @@ -316,35 +279,4 @@ public class KotlinToJVMBytecodeCompiler { } return generationState; } - - private static void reportDiagnostic(MessageCollector collector, Diagnostic diagnostic) { - DiagnosticUtils.LineAndColumn lineAndColumn = DiagnosticUtils.getLineAndColumn(diagnostic); - VirtualFile virtualFile = diagnostic.getPsiFile().getVirtualFile(); - String path = virtualFile == null ? null : virtualFile.getPath(); - collector.report(convertSeverity(diagnostic.getSeverity()), diagnostic.getMessage(), CompilerMessageLocation.create(path, lineAndColumn.getLine(), lineAndColumn.getColumn())); - } - - private static CompilerMessageSeverity convertSeverity(Severity severity) { - switch (severity) { - case INFO: - return CompilerMessageSeverity.INFO; - case ERROR: - return CompilerMessageSeverity.ERROR; - case WARNING: - return CompilerMessageSeverity.WARNING; - } - throw new IllegalStateException("Unknown severity: " + severity); - } - - private static void reportIncompleteHierarchies(MessageCollector collector, AnalyzeExhaust exhaust) { - Collection incompletes = exhaust.getBindingContext().getKeys(BindingContext.INCOMPLETE_HIERARCHY); - if (!incompletes.isEmpty()) { - StringBuilder message = new StringBuilder("The following classes have incomplete hierarchies:\n"); - for (ClassDescriptor incomplete : incompletes) { - String fqName = DescriptorUtils.getFQName(incomplete).getFqName(); - message.append(" ").append(fqName).append("\n"); - } - collector.report(CompilerMessageSeverity.ERROR, message.toString(), CompilerMessageLocation.NO_LOCATION); - } - } } diff --git a/compiler/cli/src/org/jetbrains/jet/compiler/ModuleExecutionException.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/ModuleExecutionException.java similarity index 95% rename from compiler/cli/src/org/jetbrains/jet/compiler/ModuleExecutionException.java rename to compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/ModuleExecutionException.java index 67e7a05ea34..e20d73888fd 100644 --- a/compiler/cli/src/org/jetbrains/jet/compiler/ModuleExecutionException.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/ModuleExecutionException.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; /** * @author yole diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 7ff65b75d00..a3fe4e74de8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForJavaSemanticServices { @@ -38,8 +39,14 @@ public class InjectorForJavaSemanticServices { private JavaSemanticServices javaSemanticServices; private JavaDescriptorResolver javaDescriptorResolver; private BindingTrace bindingTrace; + private JavaBridgeConfiguration javaBridgeConfiguration; private PsiClassFinderForJvm psiClassFinderForJvm; + private ModuleDescriptor moduleDescriptor; + private final CompilerDependencies compilerDependencies; + private CompilerSpecialMode compilerSpecialMode; private final Project project; + private JavaTypeTransformer javaTypeTransformer; + private NamespaceFactoryImpl namespaceFactoryImpl; public InjectorForJavaSemanticServices( @NotNull CompilerDependencies compilerDependencies, @@ -48,13 +55,14 @@ public class InjectorForJavaSemanticServices { this.javaSemanticServices = new JavaSemanticServices(); this.javaDescriptorResolver = new JavaDescriptorResolver(); this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext(); - JavaBridgeConfiguration javaBridgeConfiguration = new JavaBridgeConfiguration(); + this.javaBridgeConfiguration = new JavaBridgeConfiguration(); this.psiClassFinderForJvm = new PsiClassFinderForJvm(); - ModuleDescriptor moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(""); - CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); + this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(""); + this.compilerDependencies = compilerDependencies; + this.compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); this.project = project; - JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); - NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); + this.javaTypeTransformer = new JavaTypeTransformer(); + this.namespaceFactoryImpl = new NamespaceFactoryImpl(); this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); this.javaSemanticServices.setPsiClassFinder(psiClassFinderForJvm); @@ -87,6 +95,10 @@ public class InjectorForJavaSemanticServices { } + @PreDestroy + public void destroy() { + } + public JavaSemanticServices getJavaSemanticServices() { return this.javaSemanticServices; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index f90be7eefc1..69366baf299 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForTopDownAnalyzerForJvm { @@ -68,7 +69,28 @@ public class InjectorForTopDownAnalyzerForJvm { private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; private final ObservableBindingTrace observableBindingTrace; + private final ModuleDescriptor moduleDescriptor; + private final JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory; + private final CompilerDependencies compilerDependencies; + private CompilerSpecialMode compilerSpecialMode; private JavaBridgeConfiguration javaBridgeConfiguration; + private PsiClassFinderForJvm psiClassFinderForJvm; + private DeclarationResolver declarationResolver; + private AnnotationResolver annotationResolver; + private CallResolver callResolver; + private ExpressionTypingServices expressionTypingServices; + private TypeResolver typeResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + private OverloadingConflictResolver overloadingConflictResolver; + private ImportsResolver importsResolver; + private DelegationResolver delegationResolver; + private NamespaceFactoryImpl namespaceFactoryImpl; + private OverloadResolver overloadResolver; + private OverrideResolver overrideResolver; + private TypeHierarchyResolver typeHierarchyResolver; + private JavaSemanticServices javaSemanticServices; + private JavaDescriptorResolver javaDescriptorResolver; + private JavaTypeTransformer javaTypeTransformer; public InjectorForTopDownAnalyzerForJvm( @NotNull Project project, @@ -87,25 +109,28 @@ public class InjectorForTopDownAnalyzerForJvm { this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; this.observableBindingTrace = observableBindingTrace; - CompilerSpecialMode compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); + this.moduleDescriptor = moduleDescriptor; + this.jetControlFlowDataTraceFactory = jetControlFlowDataTraceFactory; + this.compilerDependencies = compilerDependencies; + this.compilerSpecialMode = compilerDependencies.getCompilerSpecialMode(); this.javaBridgeConfiguration = new JavaBridgeConfiguration(); - PsiClassFinderForJvm psiClassFinderForJvm = new PsiClassFinderForJvm(); - DeclarationResolver declarationResolver = new DeclarationResolver(); - AnnotationResolver annotationResolver = new AnnotationResolver(); - CallResolver callResolver = new CallResolver(); - ExpressionTypingServices expressionTypingServices = new ExpressionTypingServices(); - TypeResolver typeResolver = new TypeResolver(); - QualifiedExpressionResolver qualifiedExpressionResolver = new QualifiedExpressionResolver(); - OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); - ImportsResolver importsResolver = new ImportsResolver(); - DelegationResolver delegationResolver = new DelegationResolver(); - NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); - OverloadResolver overloadResolver = new OverloadResolver(); - OverrideResolver overrideResolver = new OverrideResolver(); - TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver(); - JavaSemanticServices javaSemanticServices = new JavaSemanticServices(); - JavaDescriptorResolver javaDescriptorResolver = new JavaDescriptorResolver(); - JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); + this.psiClassFinderForJvm = new PsiClassFinderForJvm(); + this.declarationResolver = new DeclarationResolver(); + this.annotationResolver = new AnnotationResolver(); + this.callResolver = new CallResolver(); + this.expressionTypingServices = new ExpressionTypingServices(); + this.typeResolver = new TypeResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.overloadingConflictResolver = new OverloadingConflictResolver(); + this.importsResolver = new ImportsResolver(); + this.delegationResolver = new DelegationResolver(); + this.namespaceFactoryImpl = new NamespaceFactoryImpl(); + this.overloadResolver = new OverloadResolver(); + this.overrideResolver = new OverrideResolver(); + this.typeHierarchyResolver = new TypeHierarchyResolver(); + this.javaSemanticServices = new JavaSemanticServices(); + this.javaDescriptorResolver = new JavaDescriptorResolver(); + this.javaTypeTransformer = new JavaTypeTransformer(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setContext(topDownAnalysisContext); @@ -217,6 +242,10 @@ public class InjectorForTopDownAnalyzerForJvm { } + @PreDestroy + public void destroy() { + } + public TopDownAnalyzer getTopDownAnalyzer() { return this.topDownAnalyzer; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 05fef231d78..97875e8ee8a 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -95,9 +95,13 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { compilerDependencies); - injector.getTopDownAnalyzer().analyzeFiles(files); + try { + injector.getTopDownAnalyzer().analyzeFiles(files); - return AnalyzeExhaust.success(bindingTraceContext.getBindingContext(), JetStandardLibrary.getInstance()); + return AnalyzeExhaust.success(bindingTraceContext.getBindingContext(), JetStandardLibrary.getInstance()); + } finally { + injector.destroy(); + } } public static AnalyzeExhaust shallowAnalyzeFiles(Collection files, diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java index caea1d27035..05075e34c10 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerDependencies.java @@ -33,12 +33,15 @@ public class CompilerDependencies { @NotNull private final CompilerSpecialMode compilerSpecialMode; @Nullable + private final File jdkJar; + @Nullable private final File jdkHeadersJar; @Nullable private final File runtimeJar; - public CompilerDependencies(@NotNull CompilerSpecialMode compilerSpecialMode, @Nullable File jdkHeadersJar, @Nullable File runtimeJar) { + public CompilerDependencies(@NotNull CompilerSpecialMode compilerSpecialMode, @Nullable File jdkJar, @Nullable File jdkHeadersJar, @Nullable File runtimeJar) { this.compilerSpecialMode = compilerSpecialMode; + this.jdkJar = jdkJar; this.jdkHeadersJar = jdkHeadersJar; this.runtimeJar = runtimeJar; @@ -59,6 +62,11 @@ public class CompilerDependencies { return compilerSpecialMode; } + @Nullable + public File getJdkJar() { + return jdkJar; + } + @Nullable public File getJdkHeadersJar() { return jdkHeadersJar; @@ -93,8 +101,36 @@ public class CompilerDependencies { public static CompilerDependencies compilerDependenciesForProduction(@NotNull CompilerSpecialMode compilerSpecialMode) { return new CompilerDependencies( compilerSpecialMode, + findRtJar(), compilerSpecialMode.includeJdkHeaders() ? PathUtil.getAltHeadersPath() : null, compilerSpecialMode.includeKotlinRuntime() ? PathUtil.getDefaultRuntimePath() : null); } + public static File findRtJar() { + String javaHome = System.getProperty("java.home"); + if ("jre".equals(new File(javaHome).getName())) { + javaHome = new File(javaHome).getParent(); + } + + File rtJar = findRtJar(javaHome); + + if (rtJar == null || !rtJar.exists()) { + throw new IllegalArgumentException("No JDK rt.jar found under " + javaHome); + } + + return rtJar; + } + + private static File findRtJar(String javaHome) { + File rtJar = new File(javaHome, "jre/lib/rt.jar"); + if (rtJar.exists()) { + return rtJar; + } + + File classesJar = new File(new File(javaHome).getParentFile().getAbsolutePath(), "Classes/classes.jar"); + if (classesJar.exists()) { + return classesJar; + } + return null; + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 9f8015a8b06..556323eed38 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -76,7 +76,6 @@ import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.FqName; import org.jetbrains.jet.lang.resolve.NamespaceFactory; @@ -93,7 +92,6 @@ import org.jetbrains.jet.lang.resolve.constants.NullValue; import org.jetbrains.jet.lang.resolve.constants.ShortValue; import org.jetbrains.jet.lang.resolve.constants.StringValue; import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; -import org.jetbrains.jet.lang.types.DeferredType; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeSubstitutor; @@ -105,7 +103,6 @@ import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; import org.jetbrains.jet.rt.signature.JetSignatureReader; import org.jetbrains.jet.rt.signature.JetSignatureVisitor; -import org.jetbrains.jet.util.lazy.LazyValue; import javax.inject.Inject; import java.util.ArrayList; @@ -209,11 +206,9 @@ public class JavaDescriptorResolver { final PsiClass psiClass; @Nullable final PsiPackage psiPackage; - @NotNull final FqName fqName; final boolean staticMembers; final boolean kotlin; - @NotNull final ClassOrNamespaceDescriptor classOrNamespaceDescriptor; protected ResolverScopeData(@Nullable PsiClass psiClass, @Nullable PsiPackage psiPackage, @NotNull FqName fqName, boolean staticMembers, @NotNull ClassOrNamespaceDescriptor descriptor) { @@ -237,6 +232,22 @@ public class JavaDescriptorResolver { classOrNamespaceDescriptor = descriptor; } + protected ResolverScopeData(boolean negative) { + if (!negative) { + throw new IllegalStateException(); + } + this.psiClass = null; + this.psiPackage = null; + this.fqName = null; + this.staticMembers = false; + this.kotlin = false; + this.classOrNamespaceDescriptor = null; + } + + public boolean isPositive() { + return this.classOrNamespaceDescriptor != null; + } + @NotNull public PsiElement getPsiPackageOrPsiClass() { if (psiPackage != null) { @@ -262,6 +273,13 @@ public class JavaDescriptorResolver { this.classDescriptor = classDescriptor; } + private ResolverBinaryClassData(boolean negative) { + super(negative); + this.classDescriptor = null; + } + + static final ResolverBinaryClassData NEGATIVE = new ResolverBinaryClassData(true); + List typeParameters; @NotNull @@ -286,6 +304,13 @@ public class JavaDescriptorResolver { this.namespaceDescriptor = namespaceDescriptor; } + private ResolverNamespaceData(boolean negative) { + super(negative); + this.namespaceDescriptor = null; + } + + static final ResolverNamespaceData NEGATIVE = new ResolverNamespaceData(true); + private JavaPackageScope memberScope; @NotNull @@ -374,13 +399,18 @@ public class JavaDescriptorResolver { if (classData == null) { PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW); if (psiClass == null) { + ResolverBinaryClassData oldValue = classDescriptorCache.put(qualifiedName, ResolverBinaryClassData.NEGATIVE); + if (oldValue != null) { + throw new IllegalStateException("rewrite at " + qualifiedName); + } return null; } classData = createJavaClassDescriptor(psiClass, tasks); } - return classData.getClassDescriptor(); + return classData.classDescriptor; } + @NotNull private ResolverBinaryClassData createJavaClassDescriptor(@NotNull final PsiClass psiClass, List taskList) { FqName fqName = new FqName(psiClass.getQualifiedName()); if (classDescriptorCache.containsKey(fqName)) { @@ -392,18 +422,21 @@ public class JavaDescriptorResolver { String name = psiClass.getName(); ClassKind kind = psiClass.isInterface() ? (psiClass.isAnnotationType() ? ClassKind.ANNOTATION_CLASS : ClassKind.TRAIT) : ClassKind.CLASS; ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass); - ResolverBinaryClassData classData = new ResolverBinaryClassData(psiClass, fqName, new MutableClassDescriptorLite(containingDeclaration, kind)); + + // class may be resolved during resolution of parent + ResolverBinaryClassData classData = classDescriptorCache.get(fqName); + if (classData != null) { + return classData; + } + + classData = new ResolverBinaryClassData(psiClass, fqName, new MutableClassDescriptorLite(containingDeclaration, kind)); classDescriptorCache.put(fqName, classData); classData.classDescriptor.setName(name); classData.classDescriptor.setAnnotations(resolveAnnotations(psiClass, taskList)); List supertypes = new ArrayList(); - TypeVariableResolver outerTypeVariableByNameResolver = TypeVariableResolvers.classTypeVariableResolver( - (ClassOrNamespaceDescriptor) classData.classDescriptor.getContainingDeclaration(), - "class " + psiClass.getQualifiedName()); - - classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData, outerTypeVariableByNameResolver); + classData.typeParameters = createUninitializedClassTypeParameters(psiClass, classData); List typeParameters = new ArrayList(); for (TypeParameterDescriptorInitialization typeParameter : classData.typeParameters) { @@ -583,7 +616,7 @@ public class JavaDescriptorResolver { return classData.classDescriptor; } - private List createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData, TypeVariableResolver typeVariableResolver) { + private List createUninitializedClassTypeParameters(PsiClass psiClass, ResolverBinaryClassData classData) { JetClassAnnotation jetClassAnnotation = JetClassAnnotation.get(psiClass); if (jetClassAnnotation.signature().length() > 0) { @@ -974,6 +1007,10 @@ public class JavaDescriptorResolver { break lookingForPsi; } + ResolverNamespaceData oldValue = namespaceDescriptorCacheByFqn.put(fqName, ResolverNamespaceData.NEGATIVE); + if (oldValue != null) { + throw new IllegalStateException("rewrite at " + fqName); + } return null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java b/compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java index 88e8988b2c5..3cf3bedd3f3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/checkers/CheckerTestUtil.java @@ -320,12 +320,6 @@ public class CheckerTestUtil { return SyntaxErrorDiagnosticFactory.instance; } - @NotNull - @Override - public String getMessage() { - throw new IllegalStateException(); - } - @NotNull @Override public Severity getSeverity() { diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index ca570d75b93..23020ab2793 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -27,24 +27,31 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForMacros { private ExpressionTypingServices expressionTypingServices; private final Project project; + private CallResolver callResolver; + private DescriptorResolver descriptorResolver; + private AnnotationResolver annotationResolver; + private TypeResolver typeResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + private OverloadingConflictResolver overloadingConflictResolver; public InjectorForMacros( @NotNull Project project ) { this.expressionTypingServices = new ExpressionTypingServices(); this.project = project; - CallResolver callResolver = new CallResolver(); - DescriptorResolver descriptorResolver = new DescriptorResolver(); - AnnotationResolver annotationResolver = new AnnotationResolver(); - TypeResolver typeResolver = new TypeResolver(); - QualifiedExpressionResolver qualifiedExpressionResolver = new QualifiedExpressionResolver(); - OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); + this.callResolver = new CallResolver(); + this.descriptorResolver = new DescriptorResolver(); + this.annotationResolver = new AnnotationResolver(); + this.typeResolver = new TypeResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.overloadingConflictResolver = new OverloadingConflictResolver(); this.expressionTypingServices.setCallResolver(callResolver); this.expressionTypingServices.setDescriptorResolver(descriptorResolver); @@ -69,6 +76,10 @@ public class InjectorForMacros { } + @PreDestroy + public void destroy() { + } + public ExpressionTypingServices getExpressionTypingServices() { return this.expressionTypingServices; } diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 7c8405cfa5a..569ef4f592c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -49,6 +49,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForTopDownAnalyzerBasic { @@ -62,6 +63,22 @@ public class InjectorForTopDownAnalyzerBasic { private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; private final ObservableBindingTrace observableBindingTrace; + private final ModuleDescriptor moduleDescriptor; + private final JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory; + private final ModuleConfiguration moduleConfiguration; + private DeclarationResolver declarationResolver; + private AnnotationResolver annotationResolver; + private CallResolver callResolver; + private ExpressionTypingServices expressionTypingServices; + private TypeResolver typeResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + private OverloadingConflictResolver overloadingConflictResolver; + private ImportsResolver importsResolver; + private DelegationResolver delegationResolver; + private NamespaceFactoryImpl namespaceFactoryImpl; + private OverloadResolver overloadResolver; + private OverrideResolver overrideResolver; + private TypeHierarchyResolver typeHierarchyResolver; public InjectorForTopDownAnalyzerBasic( @NotNull Project project, @@ -80,19 +97,22 @@ public class InjectorForTopDownAnalyzerBasic { this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; this.observableBindingTrace = observableBindingTrace; - DeclarationResolver declarationResolver = new DeclarationResolver(); - AnnotationResolver annotationResolver = new AnnotationResolver(); - CallResolver callResolver = new CallResolver(); - ExpressionTypingServices expressionTypingServices = new ExpressionTypingServices(); - TypeResolver typeResolver = new TypeResolver(); - QualifiedExpressionResolver qualifiedExpressionResolver = new QualifiedExpressionResolver(); - OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); - ImportsResolver importsResolver = new ImportsResolver(); - DelegationResolver delegationResolver = new DelegationResolver(); - NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); - OverloadResolver overloadResolver = new OverloadResolver(); - OverrideResolver overrideResolver = new OverrideResolver(); - TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver(); + this.moduleDescriptor = moduleDescriptor; + this.jetControlFlowDataTraceFactory = jetControlFlowDataTraceFactory; + this.moduleConfiguration = moduleConfiguration; + this.declarationResolver = new DeclarationResolver(); + this.annotationResolver = new AnnotationResolver(); + this.callResolver = new CallResolver(); + this.expressionTypingServices = new ExpressionTypingServices(); + this.typeResolver = new TypeResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.overloadingConflictResolver = new OverloadingConflictResolver(); + this.importsResolver = new ImportsResolver(); + this.delegationResolver = new DelegationResolver(); + this.namespaceFactoryImpl = new NamespaceFactoryImpl(); + this.overloadResolver = new OverloadResolver(); + this.overrideResolver = new OverrideResolver(); + this.typeHierarchyResolver = new TypeHierarchyResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setContext(topDownAnalysisContext); @@ -179,6 +199,10 @@ public class InjectorForTopDownAnalyzerBasic { } + @PreDestroy + public void destroy() { + } + public TopDownAnalyzer getTopDownAnalyzer() { return this.topDownAnalyzer; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnostic.java index 3e1622aa486..33450c87fe2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnostic.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnostic.java @@ -25,15 +25,15 @@ import org.jetbrains.annotations.NotNull; */ public abstract class AbstractDiagnostic implements ParametrizedDiagnostic { private final E psiElement; - private final String message; private final AbstractDiagnosticFactory factory; private final Severity severity; - public AbstractDiagnostic(@NotNull E psiElement, @NotNull AbstractDiagnosticFactory factory, @NotNull Severity severity, @NotNull String message) { + public AbstractDiagnostic(@NotNull E psiElement, + @NotNull AbstractDiagnosticFactory factory, + @NotNull Severity severity) { this.psiElement = psiElement; this.factory = factory; this.severity = severity; - this.message = message; } @NotNull @@ -48,19 +48,12 @@ public abstract class AbstractDiagnostic implements Parame return psiElement.getContainingFile(); } - @NotNull - @Override - public String getMessage() { - return message; - } - @NotNull @Override public Severity getSeverity() { return severity; } - @Override @NotNull public E getPsiElement() { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java index 8d6198a8a58..aeebc9f633f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AbstractDiagnosticFactory.java @@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.diagnostics; /** * @author abreslav */ -public class AbstractDiagnosticFactory { +public abstract class AbstractDiagnosticFactory { private String name = null; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java index 57cf016fdb4..809012d233b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java @@ -17,11 +17,8 @@ package org.jetbrains.jet.lang.diagnostics; import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; -import org.jetbrains.jet.resolve.DescriptorRenderer; import java.util.Collection; @@ -29,24 +26,11 @@ import java.util.Collection; * @author abreslav */ public class AmbiguousDescriptorDiagnosticFactory extends DiagnosticFactory1>> { - public static AmbiguousDescriptorDiagnosticFactory create(String messageTemplate) { - return new AmbiguousDescriptorDiagnosticFactory(messageTemplate); + public static AmbiguousDescriptorDiagnosticFactory create() { + return new AmbiguousDescriptorDiagnosticFactory(); } - public AmbiguousDescriptorDiagnosticFactory(String messageTemplate) { - super(Severity.ERROR, messageTemplate, PositioningStrategies.DEFAULT, AMBIGUOUS_DESCRIPTOR_RENDERER); + public AmbiguousDescriptorDiagnosticFactory() { + super(Severity.ERROR, PositioningStrategies.DEFAULT); } - - private static Renderer>> AMBIGUOUS_DESCRIPTOR_RENDERER = - new Renderer>>() { - @NotNull - @Override - public String render(@Nullable Collection> argument) { - StringBuilder stringBuilder = new StringBuilder("\n"); - for (ResolvedCall call : argument) { - stringBuilder.append(DescriptorRenderer.TEXT.render(call.getResultingDescriptor())).append("\n"); - } - return stringBuilder.toString(); - } - }; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java index d4369a0513d..8fcfbf18762 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Diagnostic.java @@ -31,9 +31,6 @@ public interface Diagnostic { @NotNull AbstractDiagnosticFactory getFactory(); - @NotNull - String getMessage(); - @NotNull Severity getSeverity(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory.java deleted file mode 100644 index 5e893eef3f1..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * 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.lang.diagnostics; - -import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; - -/** - * @author svtk - */ -public class DiagnosticFactory extends DiagnosticFactoryWithPsiElement { - protected final String message; - - protected DiagnosticFactory(Severity severity, String message, PositioningStrategy positioningStrategy) { - super(severity, positioningStrategy); - this.message = message; - } - - public static DiagnosticFactory create(Severity severity, String message) { - return create(severity, message, PositioningStrategies.DEFAULT); - } - - public static DiagnosticFactory create(Severity severity, String message, PositioningStrategy positioningStrategy) { - return new DiagnosticFactory(severity, message, positioningStrategy); - } - - @NotNull - public ParametrizedDiagnostic on(@NotNull E element) { - return new DiagnosticWithPsiElement(element, this, severity, message); - } -} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory1.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory1.java index c6e1d9d3f91..ebc4ebe4b23 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory1.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory1.java @@ -22,40 +22,21 @@ import org.jetbrains.annotations.NotNull; /** * @author svtk */ -public class DiagnosticFactory1 extends DiagnosticFactoryWithMessageFormat { - private final Renderer renderer; - - protected String makeMessage(@NotNull A argument) { - return messageFormat.format(new Object[]{makeMessageFor(argument)}); - } - - protected String makeMessageFor(@NotNull A argument) { - return renderer.render(argument); - } - +public class DiagnosticFactory1 extends DiagnosticFactoryWithPsiElement { @NotNull public ParametrizedDiagnostic on(@NotNull E element, @NotNull A argument) { - return new DiagnosticWithPsiElement(element, this, severity, makeMessage(argument)); + return new DiagnosticWithParameters1(element, argument, this, severity); } - protected DiagnosticFactory1(Severity severity, String message, PositioningStrategy positioningStrategy, Renderer renderer) { - super(severity, message, positioningStrategy); - this.renderer = renderer; + protected DiagnosticFactory1(Severity severity, PositioningStrategy positioningStrategy) { + super(severity, positioningStrategy); } - public static DiagnosticFactory1 create(Severity severity, String message, PositioningStrategy positioningStrategy, Renderer renderer) { - return new DiagnosticFactory1(severity, message, positioningStrategy, renderer); + public static DiagnosticFactory1 create(Severity severity, PositioningStrategy positioningStrategy) { + return new DiagnosticFactory1(severity, positioningStrategy); } - public static DiagnosticFactory1 create(Severity severity, String message, PositioningStrategy positioningStrategy) { - return create(severity, message, positioningStrategy, Renderers.TO_STRING); - } - - public static DiagnosticFactory1 create(Severity severity, String message, Renderer renderer) { - return create(severity, message, PositioningStrategies.DEFAULT, renderer); - } - - public static DiagnosticFactory1 create(Severity severity, String message) { - return create(severity, message, PositioningStrategies.DEFAULT, Renderers.TO_STRING); + public static DiagnosticFactory1 create(Severity severity) { + return create(severity, PositioningStrategies.DEFAULT); } } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory2.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory2.java index 8eb63ff8c04..5f63a87870b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory2.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory2.java @@ -22,48 +22,23 @@ import org.jetbrains.annotations.NotNull; /** * @author abreslav */ -public class DiagnosticFactory2 extends DiagnosticFactoryWithMessageFormat { - private final Renderer rendererForA; - private final Renderer rendererForB; - - private String makeMessage(@NotNull A a, @NotNull B b) { - return messageFormat.format(new Object[] {makeMessageForA(a), makeMessageForB(b)}); - } - - private String makeMessageForA(@NotNull A a) { - return rendererForA.render(a); - } - - private String makeMessageForB(@NotNull B b) { - return rendererForB.render(b); - } +public class DiagnosticFactory2 extends DiagnosticFactoryWithPsiElement { @NotNull public ParametrizedDiagnostic on(@NotNull E element, @NotNull A a, @NotNull B b) { - return new DiagnosticWithPsiElement(element, this, severity, makeMessage(a, b)); + return new DiagnosticWithParameters2(element, a, b, this, severity); } - - private DiagnosticFactory2(Severity severity, String message, PositioningStrategy positioningStrategy, Renderer rendererForA, Renderer rendererForB) { - super(severity, message, positioningStrategy); - this.rendererForA = rendererForA; - this.rendererForB = rendererForB; + private DiagnosticFactory2(Severity severity, PositioningStrategy positioningStrategy) { + super(severity, positioningStrategy); } - public static DiagnosticFactory2 create(Severity severity, String messageStub, PositioningStrategy positioningStrategy, Renderer rendererForA, Renderer rendererForB) { - return new DiagnosticFactory2(severity, messageStub, positioningStrategy, rendererForA, rendererForB); + public static DiagnosticFactory2 create(Severity severity, PositioningStrategy positioningStrategy) { + return new DiagnosticFactory2(severity, positioningStrategy); } - public static DiagnosticFactory2 create(Severity severity, String messageStub, PositioningStrategy positioningStrategy) { - return new DiagnosticFactory2(severity, messageStub, positioningStrategy, Renderers.TO_STRING, Renderers.TO_STRING); - } - - public static DiagnosticFactory2 create(Severity severity, String messageStub, Renderer rendererForA, Renderer rendererForB) { - return new DiagnosticFactory2(severity, messageStub, PositioningStrategies.DEFAULT, rendererForA, rendererForB); - } - - public static DiagnosticFactory2 create(Severity severity, String messageStub) { - return new DiagnosticFactory2(severity, messageStub, PositioningStrategies.DEFAULT, Renderers.TO_STRING, Renderers.TO_STRING); + public static DiagnosticFactory2 create(Severity severity) { + return new DiagnosticFactory2(severity, PositioningStrategies.DEFAULT); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory3.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory3.java index caa5b8518e1..2bb0deb23da 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory3.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactory3.java @@ -22,51 +22,22 @@ import org.jetbrains.annotations.NotNull; /** * @author svtk */ -public class DiagnosticFactory3 extends DiagnosticFactoryWithMessageFormat { - private final Renderer rendererForA; - private final Renderer rendererForB; - private final Renderer rendererForC; - - protected DiagnosticFactory3(Severity severity, String messageStub, PositioningStrategy positioningStrategy, Renderer rendererForA, Renderer rendererForB, Renderer rendererForC) { - super(severity, messageStub, positioningStrategy); - this.rendererForA = rendererForA; - this.rendererForB = rendererForB; - this.rendererForC = rendererForC; +public class DiagnosticFactory3 extends DiagnosticFactoryWithPsiElement { + + protected DiagnosticFactory3(Severity severity, PositioningStrategy positioningStrategy) { + super(severity, positioningStrategy); } - public static DiagnosticFactory3 create(Severity severity, String messageStub) { - return create(severity, messageStub, PositioningStrategies.DEFAULT); + public static DiagnosticFactory3 create(Severity severity) { + return create(severity, PositioningStrategies.DEFAULT); } - public static DiagnosticFactory3 create(Severity severity, String messageStub, PositioningStrategy positioningStrategy) { - return create(severity, messageStub, positioningStrategy, Renderers.TO_STRING, Renderers.TO_STRING, Renderers.TO_STRING); + public static DiagnosticFactory3 create(Severity severity, PositioningStrategy positioningStrategy) { + return new DiagnosticFactory3(severity, positioningStrategy); } - public static DiagnosticFactory3 create(Severity severity, String messageStub, Renderer rendererForA, Renderer rendererForB, Renderer rendererForC) { - return create(severity, messageStub, PositioningStrategies.DEFAULT, rendererForA, rendererForB, rendererForC); - } - - public static DiagnosticFactory3 create(Severity severity, String messageStub, PositioningStrategy positioningStrategy, Renderer rendererForA, Renderer rendererForB, Renderer rendererForC) { - return new DiagnosticFactory3(severity, messageStub, positioningStrategy, rendererForA, rendererForB, rendererForC); - } - - private String makeMessage(@NotNull A a, @NotNull B b, @NotNull C c) { - return messageFormat.format(new Object[]{makeMessageForA(a), makeMessageForB(b), makeMessageForC(c)}); - } - - private String makeMessageForA(@NotNull A a) { - return rendererForA.render(a); - } - - private String makeMessageForB(@NotNull B b) { - return rendererForB.render(b); - } - - private String makeMessageForC(@NotNull C c) { - return rendererForC.render(c); - } @NotNull public ParametrizedDiagnostic on(@NotNull E element, @NotNull A a, @NotNull B b, @NotNull C c) { - return new DiagnosticWithPsiElement(element, this, severity, makeMessage(a, b, c)); + return new DiagnosticWithParameters3(element, a, b, c, this, severity); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithMessageFormat.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithMessageFormat.java deleted file mode 100644 index 9478ec5191d..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithMessageFormat.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * 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.lang.diagnostics; - -import com.intellij.psi.PsiElement; - -import java.text.MessageFormat; - -/** -* @author abreslav -*/ -public abstract class DiagnosticFactoryWithMessageFormat extends DiagnosticFactoryWithPsiElement { - protected final MessageFormat messageFormat; - - public DiagnosticFactoryWithMessageFormat(Severity severity, String message) { - this(severity, message, PositioningStrategies.DEFAULT); - } - - public DiagnosticFactoryWithMessageFormat(Severity severity, String message, PositioningStrategy positioningStrategy) { - super(severity, positioningStrategy); - this.messageFormat = new MessageFormat(message); - } -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java index f0c110e14bd..c1f1472d2c5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticHolder.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.diagnostics; import com.intellij.openapi.util.TextRange; -import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; @@ -38,7 +37,7 @@ public interface DiagnosticHolder { if (diagnostic.getSeverity() == Severity.ERROR) { PsiFile psiFile = diagnostic.getPsiFile(); List textRanges = diagnostic.getTextRanges(); - throw new IllegalStateException(diagnostic.getMessage() + DiagnosticUtils.atLocation(psiFile, textRanges.get(0))); + throw new IllegalStateException(diagnostic.getFactory().getName() + DiagnosticUtils.atLocation(psiFile, textRanges.get(0))); } } }; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java index 67ab02f1d5f..be456c83593 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java @@ -80,11 +80,16 @@ public class DiagnosticUtils { @NotNull public static LineAndColumn getLineAndColumn(@NotNull Diagnostic diagnostic) { PsiFile file = diagnostic.getPsiFile(); - Document document = file.getViewProvider().getDocument(); List textRanges = diagnostic.getTextRanges(); if (textRanges.isEmpty()) return LineAndColumn.NONE; TextRange firstRange = textRanges.iterator().next(); - return offsetToLineAndColumn(document, firstRange.getStartOffset()); + return getLineAndColumnInPsiFile(file, firstRange); + } + + @NotNull + public static LineAndColumn getLineAndColumnInPsiFile(PsiFile file, TextRange range) { + Document document = file.getViewProvider().getDocument(); + return offsetToLineAndColumn(document, range.getStartOffset()); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters1.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters1.java new file mode 100644 index 00000000000..50976c627c4 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters1.java @@ -0,0 +1,56 @@ +/* + * 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.lang.diagnostics; + +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; + +import java.util.List; + +/** + * @author Evgeny Gerashchenko + * @since 4/11/12 + */ +public class DiagnosticWithParameters1 extends AbstractDiagnostic { + private A a; + + public DiagnosticWithParameters1(@NotNull E psiElement, + @NotNull A a, + @NotNull DiagnosticFactory1 factory, + @NotNull Severity severity) { + super(psiElement, factory, severity); + this.a = a; + } + + @NotNull + @Override + public DiagnosticFactory1 getFactory() { + return (DiagnosticFactory1)super.getFactory(); + } + + @Override + @NotNull + public List getTextRanges() { + return getFactory().getTextRanges(this); + } + + @NotNull + public A getA() { + return a; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters2.java similarity index 50% rename from compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java rename to compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters2.java index 8b1f2242987..272577dcfba 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters2.java @@ -17,37 +17,48 @@ package org.jetbrains.jet.lang.diagnostics; import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.JetArrayAccessExpression; -import org.jetbrains.jet.lang.psi.JetReferenceExpression; -import java.util.Collections; import java.util.List; -import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR; - /** - * @author abreslav + * @author Evgeny Gerashchenko + * @since 4/11/12 */ -public class UnresolvedReferenceDiagnostic extends AbstractDiagnostic { +public class DiagnosticWithParameters2 extends AbstractDiagnostic { + private A a; + private B b; - public UnresolvedReferenceDiagnostic(JetReferenceExpression referenceExpression, String message) { - super(referenceExpression, Errors.UNRESOLVED_REFERENCE, ERROR, message); + public DiagnosticWithParameters2(@NotNull E psiElement, + @NotNull A a, + @NotNull B b, + @NotNull DiagnosticFactory2 factory, + @NotNull Severity severity) { + super(psiElement, factory, severity); + this.a = a; + this.b = b; } @NotNull @Override - public String getMessage() { - return super.getMessage() + ": " + getPsiElement().getText(); + public DiagnosticFactory2 getFactory() { + return (DiagnosticFactory2)super.getFactory(); } - @NotNull @Override + @NotNull public List getTextRanges() { - JetReferenceExpression element = getPsiElement(); - if (element instanceof JetArrayAccessExpression) { - return ((JetArrayAccessExpression) element).getBracketRanges(); - } - return Collections.singletonList(element.getTextRange()); + return getFactory().getTextRanges(this); + } + + @NotNull + public A getA() { + return a; + } + + @NotNull + public B getB() { + return b; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters3.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters3.java new file mode 100644 index 00000000000..febe21d7a5b --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithParameters3.java @@ -0,0 +1,72 @@ +/* + * 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.lang.diagnostics; + +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; + +import java.util.List; + +/** + * @author Evgeny Gerashchenko + * @since 4/11/12 + */ +public class DiagnosticWithParameters3 extends AbstractDiagnostic { + private A a; + private B b; + private C c; + + public DiagnosticWithParameters3(@NotNull E psiElement, + @NotNull A a, + @NotNull B b, + @NotNull C c, + @NotNull DiagnosticFactory3 factory, + @NotNull Severity severity) { + super(psiElement, factory, severity); + this.a = a; + this.b = b; + this.c = c; + } + + @NotNull + @Override + public DiagnosticFactory3 getFactory() { + return (DiagnosticFactory3)super.getFactory(); + } + + @Override + @NotNull + public List getTextRanges() { + return getFactory().getTextRanges(this); + } + + @NotNull + public A getA() { + return a; + } + + @NotNull + public B getB() { + return b; + } + + @NotNull + public C getC() { + return c; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index d2e374196ed..929f1350017 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -21,267 +21,259 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.PsiNameIdentifierOwner; import com.intellij.psi.impl.source.tree.LeafPsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.inference.SolutionStatus; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetTokens; -import org.jetbrains.jet.resolve.DescriptorRenderer; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.Collection; import java.util.Collections; -import java.util.Iterator; import java.util.List; -import static org.jetbrains.jet.lang.diagnostics.Renderers.*; import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR; import static org.jetbrains.jet.lang.diagnostics.Severity.WARNING; /** + * For error messages, see DefaultErrorMessages and IdeErrorMessages. + * * @author abreslav */ public interface Errors { - DiagnosticFactory1 EXCEPTION_WHILE_ANALYZING = DiagnosticFactory1.create(ERROR, "{0}", new Renderer() { - @NotNull - @Override - public String render(@Nullable Throwable e) { - return e.getClass().getSimpleName() + ": " + e.getMessage(); - } - }); + DiagnosticFactory1 EXCEPTION_WHILE_ANALYZING = DiagnosticFactory1.create(ERROR); - UnresolvedReferenceDiagnosticFactory UNRESOLVED_REFERENCE = UnresolvedReferenceDiagnosticFactory.create("Unresolved reference"); + UnresolvedReferenceDiagnosticFactory UNRESOLVED_REFERENCE = UnresolvedReferenceDiagnosticFactory.create(); //Elements with "INVISIBLE_REFERENCE" error are marked as unresolved, unlike elements with "INVISIBLE_MEMBER" error - DiagnosticFactory2 INVISIBLE_REFERENCE = DiagnosticFactory2.create(ERROR, "Cannot access ''{0}'' in ''{1}''", NAME, NAME); - DiagnosticFactory2 INVISIBLE_MEMBER = DiagnosticFactory2.create(ERROR, "Cannot access ''{0}'' in ''{1}''", NAME, NAME); + DiagnosticFactory2 INVISIBLE_REFERENCE = + DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 INVISIBLE_MEMBER = DiagnosticFactory2.create(ERROR); - RedeclarationDiagnosticFactory REDECLARATION = RedeclarationDiagnosticFactory.REDECLARATION; - RedeclarationDiagnosticFactory NAME_SHADOWING = RedeclarationDiagnosticFactory.NAME_SHADOWING; + RedeclarationDiagnosticFactory REDECLARATION = new RedeclarationDiagnosticFactory(ERROR); + RedeclarationDiagnosticFactory NAME_SHADOWING = new RedeclarationDiagnosticFactory(WARNING); - DiagnosticFactory2 TYPE_MISMATCH = DiagnosticFactory2.create(ERROR, "Type mismatch: inferred type is {1} but {0} was expected", - RENDER_TYPE, RENDER_TYPE); - DiagnosticFactory1> INCOMPATIBLE_MODIFIERS = - DiagnosticFactory1.create(ERROR, "Incompatible modifiers: ''{0}''", - new Renderer>() { - @NotNull - @Override - public String render(@Nullable Collection element) { - assert element != null; - StringBuilder sb = new StringBuilder(); - for (Iterator iterator = element.iterator(); iterator.hasNext(); ) { - JetKeywordToken modifier = iterator.next(); - sb.append(modifier.getValue()); - if (iterator.hasNext()) { - sb.append(" "); - } - } - return sb.toString(); - } - }); - DiagnosticFactory1 ILLEGAL_MODIFIER = DiagnosticFactory1.create(ERROR, "Illegal modifier ''{0}''"); + DiagnosticFactory2 TYPE_MISMATCH = DiagnosticFactory2.create(ERROR); + DiagnosticFactory1> INCOMPATIBLE_MODIFIERS = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 ILLEGAL_MODIFIER = DiagnosticFactory1.create(ERROR); - DiagnosticFactory2 REDUNDANT_MODIFIER = DiagnosticFactory2.create(Severity.WARNING, "Modifier {0} is redundant because {1} is present"); - DiagnosticFactory ABSTRACT_MODIFIER_IN_TRAIT = DiagnosticFactory.create(WARNING, "Modifier ''{0}'' is redundant in trait", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory OPEN_MODIFIER_IN_TRAIT = DiagnosticFactory.create(WARNING, "Modifier ''{0}'' is redundant in trait", PositioningStrategies.positionModifier(JetTokens.OPEN_KEYWORD)); - DiagnosticFactory REDUNDANT_MODIFIER_IN_GETTER = DiagnosticFactory.create(WARNING, "Visibility modifiers are redundant in getter"); - DiagnosticFactory TRAIT_CAN_NOT_BE_FINAL = DiagnosticFactory.create(ERROR, "Trait can not be final"); - DiagnosticFactory TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM = DiagnosticFactory.create(ERROR, "Type checking has run into a recursive problem. Easiest workaround: specify types of your declarations explicitly"); // TODO: message - DiagnosticFactory RETURN_NOT_ALLOWED = DiagnosticFactory.create(ERROR, "'return' is not allowed here"); - DiagnosticFactory PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE = DiagnosticFactory.create(ERROR, "Projections are not allowed for immediate arguments of a supertype", new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull JetTypeProjection element) { - return markNode(element.getProjectionNode()); - } - }); - DiagnosticFactory LABEL_NAME_CLASH = DiagnosticFactory.create(WARNING, "There is more than one label with such a name in this scope"); - DiagnosticFactory EXPRESSION_EXPECTED_NAMESPACE_FOUND = DiagnosticFactory.create(ERROR, "Expression expected, but a namespace name found"); + DiagnosticFactory2 REDUNDANT_MODIFIER = DiagnosticFactory2.create(Severity.WARNING); + SimpleDiagnosticFactory ABSTRACT_MODIFIER_IN_TRAIT = SimpleDiagnosticFactory + .create(WARNING, PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + SimpleDiagnosticFactory OPEN_MODIFIER_IN_TRAIT = SimpleDiagnosticFactory + .create(WARNING, PositioningStrategies.positionModifier(JetTokens.OPEN_KEYWORD)); + SimpleDiagnosticFactory + REDUNDANT_MODIFIER_IN_GETTER = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory TRAIT_CAN_NOT_BE_FINAL = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory RETURN_NOT_ALLOWED = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE = + SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.PROJECTION_MODIFIER); + SimpleDiagnosticFactoryLABEL_NAME_CLASH = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory EXPRESSION_EXPECTED_NAMESPACE_FOUND = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory1 CANNOT_IMPORT_FROM_ELEMENT = DiagnosticFactory1.create(ERROR, "Cannot import from ''{0}''", NAME); - DiagnosticFactory1 CANNOT_BE_IMPORTED = DiagnosticFactory1.create(ERROR, "Cannot import ''{0}'', functions and properties can be imported only from packages", NAME); - DiagnosticFactory USELESS_HIDDEN_IMPORT = DiagnosticFactory.create(WARNING, "Useless import, it is hidden further"); - DiagnosticFactory USELESS_SIMPLE_IMPORT = DiagnosticFactory.create(WARNING, "Useless import, does nothing"); + DiagnosticFactory1 CANNOT_IMPORT_FROM_ELEMENT = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 CANNOT_BE_IMPORTED = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactoryUSELESS_HIDDEN_IMPORT = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory USELESS_SIMPLE_IMPORT = SimpleDiagnosticFactory.create(WARNING); - DiagnosticFactory CANNOT_INFER_PARAMETER_TYPE = DiagnosticFactory.create(ERROR, "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation"); + SimpleDiagnosticFactory CANNOT_INFER_PARAMETER_TYPE = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory NO_BACKING_FIELD_ABSTRACT_PROPERTY = DiagnosticFactory.create(ERROR, "This property doesn't have a backing field, because it's abstract"); - DiagnosticFactory NO_BACKING_FIELD_CUSTOM_ACCESSORS = DiagnosticFactory.create(ERROR, "This property doesn't have a backing field, because it has custom accessors without reference to the backing field"); - DiagnosticFactory INACCESSIBLE_BACKING_FIELD = DiagnosticFactory.create(ERROR, "The backing field is not accessible here"); - DiagnosticFactory NOT_PROPERTY_BACKING_FIELD = DiagnosticFactory.create(ERROR, "The referenced variable is not a property and doesn't have backing field"); + SimpleDiagnosticFactory NO_BACKING_FIELD_ABSTRACT_PROPERTY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NO_BACKING_FIELD_CUSTOM_ACCESSORS = SimpleDiagnosticFactory.create(ERROR + ); + SimpleDiagnosticFactory INACCESSIBLE_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NOT_PROPERTY_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory MIXING_NAMED_AND_POSITIONED_ARGUMENTS = DiagnosticFactory.create(ERROR, "Mixing named and positioned arguments in not allowed"); - DiagnosticFactory ARGUMENT_PASSED_TWICE = DiagnosticFactory.create(ERROR, "An argument is already passed for this parameter"); - UnresolvedReferenceDiagnosticFactory NAMED_PARAMETER_NOT_FOUND = UnresolvedReferenceDiagnosticFactory.create("Cannot find a parameter with this name"); - DiagnosticFactory VARARG_OUTSIDE_PARENTHESES = DiagnosticFactory.create(ERROR, "Passing value as a vararg is only allowed inside a parenthesized argument list"); - DiagnosticFactory NON_VARARG_SPREAD = DiagnosticFactory.create(ERROR, "The spread operator (*foo) may only be applied in a vararg position"); + SimpleDiagnosticFactory MIXING_NAMED_AND_POSITIONED_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory ARGUMENT_PASSED_TWICE = SimpleDiagnosticFactory.create(ERROR); + UnresolvedReferenceDiagnosticFactory NAMED_PARAMETER_NOT_FOUND = UnresolvedReferenceDiagnosticFactory.create(); + SimpleDiagnosticFactory VARARG_OUTSIDE_PARENTHESES = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NON_VARARG_SPREAD = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory MANY_FUNCTION_LITERAL_ARGUMENTS = DiagnosticFactory.create(ERROR, "Only one function literal is allowed outside a parenthesized argument list"); - DiagnosticFactory PROPERTY_WITH_NO_TYPE_NO_INITIALIZER = DiagnosticFactory.create(ERROR, "This property must either have a type annotation or be initialized"); + SimpleDiagnosticFactory MANY_FUNCTION_LITERAL_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory PROPERTY_WITH_NO_TYPE_NO_INITIALIZER = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS = DiagnosticFactory.create(ERROR, "This property cannot be declared abstract", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory ABSTRACT_PROPERTY_NOT_IN_CLASS = DiagnosticFactory.create(ERROR, "A property may be abstract only when defined in a class or trait", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory ABSTRACT_PROPERTY_WITH_INITIALIZER = DiagnosticFactory.create(ERROR, "Property with initializer cannot be abstract"); - DiagnosticFactory ABSTRACT_PROPERTY_WITH_GETTER = DiagnosticFactory.create(ERROR, "Property with getter implementation cannot be abstract"); - DiagnosticFactory ABSTRACT_PROPERTY_WITH_SETTER = DiagnosticFactory.create(ERROR, "Property with setter implementation cannot be abstract"); + SimpleDiagnosticFactory ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS = SimpleDiagnosticFactory + .create(ERROR, PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + SimpleDiagnosticFactory ABSTRACT_PROPERTY_NOT_IN_CLASS = SimpleDiagnosticFactory.create(ERROR, + PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + SimpleDiagnosticFactory ABSTRACT_PROPERTY_WITH_INITIALIZER = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory ABSTRACT_PROPERTY_WITH_GETTER = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactoryABSTRACT_PROPERTY_WITH_SETTER = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory PACKAGE_MEMBER_CANNOT_BE_PROTECTED = DiagnosticFactory.create(ERROR, "Package member cannot be protected"); + SimpleDiagnosticFactory PACKAGE_MEMBER_CANNOT_BE_PROTECTED = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY = DiagnosticFactory.create(ERROR, "Getter visibility must be the same as property visibility"); - DiagnosticFactory BACKING_FIELD_IN_TRAIT = DiagnosticFactory.create(ERROR, "Property in a trait cannot have a backing field", PositioningStrategies.POSITION_NAME_IDENTIFIER); - DiagnosticFactory MUST_BE_INITIALIZED = DiagnosticFactory.create(ERROR, "Property must be initialized", PositioningStrategies.POSITION_NAME_IDENTIFIER); - DiagnosticFactory MUST_BE_INITIALIZED_OR_BE_ABSTRACT = DiagnosticFactory.create(ERROR, "Property must be initialized or be abstract", PositioningStrategies.POSITION_NAME_IDENTIFIER); - DiagnosticFactory PROPERTY_INITIALIZER_IN_TRAIT = DiagnosticFactory.create(ERROR, "Property initializers are not allowed in traits"); - DiagnosticFactory PROPERTY_INITIALIZER_NO_BACKING_FIELD = DiagnosticFactory.create(ERROR, "Initializer is not allowed here because this property has no backing field"); - DiagnosticFactory3 ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS = DiagnosticFactory3.create(ERROR, "Abstract property {0} in non-abstract class {1}", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory3 ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS = DiagnosticFactory3.create(ERROR, "Abstract function {0} in non-abstract class {1}", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory1 ABSTRACT_FUNCTION_WITH_BODY = DiagnosticFactory1.create(ERROR, "A function {0} with body cannot be abstract", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory1 NON_ABSTRACT_FUNCTION_WITH_NO_BODY = DiagnosticFactory1.create(ERROR, "Method {0} without a body must be abstract", PositioningStrategies.POSITION_NAME_IDENTIFIER); - DiagnosticFactory1 NON_MEMBER_ABSTRACT_FUNCTION = DiagnosticFactory1.create(ERROR, "Function {0} is not a class or trait member and cannot be abstract", PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + SimpleDiagnosticFactory GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory BACKING_FIELD_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR, + PositioningStrategies.POSITION_NAME_IDENTIFIER); + SimpleDiagnosticFactory MUST_BE_INITIALIZED = SimpleDiagnosticFactory.create(ERROR, + PositioningStrategies.POSITION_NAME_IDENTIFIER); + SimpleDiagnosticFactory MUST_BE_INITIALIZED_OR_BE_ABSTRACT = SimpleDiagnosticFactory.create(ERROR, + PositioningStrategies.POSITION_NAME_IDENTIFIER); + SimpleDiagnosticFactoryPROPERTY_INITIALIZER_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory PROPERTY_INITIALIZER_NO_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory2 ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS = + DiagnosticFactory2.create(ERROR, PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + DiagnosticFactory2 ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS = + DiagnosticFactory2.create(ERROR,PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + DiagnosticFactory1 ABSTRACT_FUNCTION_WITH_BODY = + DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_ABSTRACT_MODIFIER); + DiagnosticFactory1 NON_ABSTRACT_FUNCTION_WITH_NO_BODY = + DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER); + DiagnosticFactory1 NON_MEMBER_ABSTRACT_FUNCTION = + DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_ABSTRACT_MODIFIER); - DiagnosticFactory1 NON_MEMBER_FUNCTION_NO_BODY = DiagnosticFactory1.create(ERROR, "Function {0} must have a body", PositioningStrategies.POSITION_NAME_IDENTIFIER); - DiagnosticFactory NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticFactory.create(ERROR, "Non final member in a final class", PositioningStrategies.positionModifier(JetTokens.OPEN_KEYWORD)); + DiagnosticFactory1 NON_MEMBER_FUNCTION_NO_BODY = + DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER); + SimpleDiagnosticFactory NON_FINAL_MEMBER_IN_FINAL_CLASS = + SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.positionModifier(JetTokens.OPEN_KEYWORD)); - DiagnosticFactory PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE = DiagnosticFactory.create(ERROR, "Public or protected member should specify a type", PositioningStrategies.POSITION_NAME_IDENTIFIER); + SimpleDiagnosticFactory PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE = + SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER); - DiagnosticFactory PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = DiagnosticFactory.create(ERROR, "Projections are not allowed on type arguments of functions and properties"); // TODO : better positioning - DiagnosticFactory SUPERTYPE_NOT_INITIALIZED = DiagnosticFactory.create(ERROR, "This type has a constructor, and thus must be initialized here"); - DiagnosticFactory SUPERTYPE_NOT_INITIALIZED_DEFAULT = DiagnosticFactory.create(ERROR, "Constructor invocation should be explicitly specified"); - DiagnosticFactory SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY = DiagnosticFactory.create(ERROR, "A secondary constructor may appear only in a class that has a primary constructor"); - DiagnosticFactory SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST = DiagnosticFactory.create(ERROR, "Secondary constructors must have an initializer list"); - DiagnosticFactory BY_IN_SECONDARY_CONSTRUCTOR = DiagnosticFactory.create(ERROR, "'by'-clause is only supported for primary constructors"); - DiagnosticFactory INITIALIZER_WITH_NO_ARGUMENTS = DiagnosticFactory.create(ERROR, "Constructor arguments required"); - DiagnosticFactory MANY_CALLS_TO_THIS = DiagnosticFactory.create(ERROR, "Only one call to 'this(...)' is allowed"); - DiagnosticFactory1 NOTHING_TO_OVERRIDE = DiagnosticFactory1.create(ERROR, "{0} overrides nothing", PositioningStrategies.POSITION_OVERRIDE_MODIFIER, DescriptorRenderer.TEXT); - DiagnosticFactory3 VIRTUAL_MEMBER_HIDDEN = - DiagnosticFactory3.create(ERROR, "''{0}'' hides ''{1}'' in class {2} and needs 'override' modifier", PositioningStrategies.POSITION_NAME_IDENTIFIER, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); + SimpleDiagnosticFactory PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT = + SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.PROJECTION_MODIFIER); + SimpleDiagnosticFactory SUPERTYPE_NOT_INITIALIZED = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SUPERTYPE_NOT_INITIALIZED_DEFAULT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory BY_IN_SECONDARY_CONSTRUCTOR = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory INITIALIZER_WITH_NO_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory MANY_CALLS_TO_THIS = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory1 NOTHING_TO_OVERRIDE = + DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_OVERRIDE_MODIFIER); + DiagnosticFactory3 + VIRTUAL_MEMBER_HIDDEN = DiagnosticFactory3.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER); DiagnosticFactory3 CANNOT_OVERRIDE_INVISIBLE_MEMBER = - DiagnosticFactory3.create(ERROR, "''{0}'' cannot has no access to ''{1}'' in class {2}, so it cannot override it", PositioningStrategies.POSITION_OVERRIDE_MODIFIER, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); - DiagnosticFactory CANNOT_INFER_VISIBILITY = DiagnosticFactory.create(ERROR, "Cannot infer visibility. Please specify it explicitly", PositioningStrategies.POSITION_OVERRIDE_MODIFIER); + DiagnosticFactory3.create(ERROR, PositioningStrategies.POSITION_OVERRIDE_MODIFIER); + SimpleDiagnosticFactory CANNOT_INFER_VISIBILITY = SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.POSITION_OVERRIDE_MODIFIER); - DiagnosticFactory1 ENUM_ENTRY_SHOULD_BE_INITIALIZED = DiagnosticFactory1.create(ERROR, "Missing delegation specifier ''{0}''", PositioningStrategies.POSITION_NAME_IDENTIFIER, NAME); - DiagnosticFactory1 ENUM_ENTRY_ILLEGAL_TYPE = DiagnosticFactory1.create(ERROR, "The type constructor of enum entry should be ''{0}''", NAME); + DiagnosticFactory1 ENUM_ENTRY_SHOULD_BE_INITIALIZED = + DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER); + DiagnosticFactory1 ENUM_ENTRY_ILLEGAL_TYPE = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 UNINITIALIZED_VARIABLE = DiagnosticFactory1.create(ERROR, "Variable ''{0}'' must be initialized", NAME); - DiagnosticFactory1 UNINITIALIZED_PARAMETER = DiagnosticFactory1.create(ERROR, "Parameter ''{0}'' is uninitialized here", NAME); - UnusedElementDiagnosticFactory UNUSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is never used", PositioningStrategies.POSITION_NAME_IDENTIFIER, NAME); - UnusedElementDiagnosticFactory UNUSED_PARAMETER = UnusedElementDiagnosticFactory.create(WARNING, "Parameter ''{0}'' is never used", PositioningStrategies.POSITION_NAME_IDENTIFIER, NAME); - UnusedElementDiagnosticFactory ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is assigned but never accessed", PositioningStrategies.POSITION_NAME_IDENTIFIER, NAME); - DiagnosticFactory1 VARIABLE_WITH_REDUNDANT_INITIALIZER = DiagnosticFactory1.create(WARNING, "Variable ''{0}'' initializer is redundant", NAME); - DiagnosticFactory2 UNUSED_VALUE = DiagnosticFactory2.create(WARNING, "The value ''{0}'' assigned to ''{1}'' is never used", ELEMENT_TEXT, TO_STRING); - DiagnosticFactory1 UNUSED_CHANGED_VALUE = DiagnosticFactory1.create(WARNING, "The value changed at ''{0}'' is never used", ELEMENT_TEXT); - DiagnosticFactory UNUSED_EXPRESSION = DiagnosticFactory.create(WARNING, "The expression is unused"); - DiagnosticFactory UNUSED_FUNCTION_LITERAL = DiagnosticFactory.create(WARNING, "The function literal is unused. If you mean block, you can use 'run { ... }'"); + DiagnosticFactory1 UNINITIALIZED_VARIABLE = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 UNINITIALIZED_PARAMETER = DiagnosticFactory1.create(ERROR); + UnusedElementDiagnosticFactory UNUSED_VARIABLE = + UnusedElementDiagnosticFactory.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER); + UnusedElementDiagnosticFactory UNUSED_PARAMETER = + UnusedElementDiagnosticFactory.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER); + UnusedElementDiagnosticFactory ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = + UnusedElementDiagnosticFactory.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER); + DiagnosticFactory1 VARIABLE_WITH_REDUNDANT_INITIALIZER = DiagnosticFactory1.create(WARNING); + DiagnosticFactory2 UNUSED_VALUE = DiagnosticFactory2.create(WARNING); + DiagnosticFactory1 UNUSED_CHANGED_VALUE = DiagnosticFactory1.create(WARNING); + SimpleDiagnosticFactory UNUSED_EXPRESSION = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory UNUSED_FUNCTION_LITERAL = SimpleDiagnosticFactory.create(WARNING); - DiagnosticFactory1 VAL_REASSIGNMENT = DiagnosticFactory1.create(ERROR, "Val can not be reassigned", NAME); - DiagnosticFactory1 INITIALIZATION_BEFORE_DECLARATION = DiagnosticFactory1.create(ERROR, "Variable cannot be initialized before declaration", NAME); - DiagnosticFactory VARIABLE_EXPECTED = DiagnosticFactory.create(ERROR, "Variable expected"); + DiagnosticFactory1 VAL_REASSIGNMENT = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 INITIALIZATION_BEFORE_DECLARATION = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactory VARIABLE_EXPECTED = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory1 INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER = DiagnosticFactory1.create(ERROR, "This property has a custom setter, so initialization using backing field required", NAME); - DiagnosticFactory1 INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER = DiagnosticFactory1.create(ERROR, "Setter of this property can be overridden, so initialization using backing field required", NAME); + DiagnosticFactory1 INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 FUNCTION_PARAMETERS_OF_INLINE_FUNCTION = DiagnosticFactory1.create(ERROR, "Function parameters of inline function can only be invoked", NAME); + DiagnosticFactory1 FUNCTION_PARAMETERS_OF_INLINE_FUNCTION = DiagnosticFactory1.create(ERROR); - DiagnosticFactory UNREACHABLE_CODE = DiagnosticFactory.create(ERROR, "Unreachable code"); + SimpleDiagnosticFactory UNREACHABLE_CODE = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory MANY_CLASS_OBJECTS = DiagnosticFactory.create(ERROR, "Only one class object is allowed per class"); - DiagnosticFactory CLASS_OBJECT_NOT_ALLOWED = DiagnosticFactory.create(ERROR, "A class object is not allowed here"); - DiagnosticFactory DELEGATION_IN_TRAIT = DiagnosticFactory.create(ERROR, "Traits cannot use delegation"); - DiagnosticFactory DELEGATION_NOT_TO_TRAIT = DiagnosticFactory.create(ERROR, "Only traits can be delegated to"); - DiagnosticFactory NO_CONSTRUCTOR = DiagnosticFactory.create(ERROR, "This class does not have a constructor"); - DiagnosticFactory NOT_A_CLASS = DiagnosticFactory.create(ERROR, "Not a class"); - DiagnosticFactory ILLEGAL_ESCAPE_SEQUENCE = DiagnosticFactory.create(ERROR, "Illegal escape sequence"); + SimpleDiagnosticFactory MANY_CLASS_OBJECTS = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory CLASS_OBJECT_NOT_ALLOWED = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory DELEGATION_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory DELEGATION_NOT_TO_TRAIT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NO_CONSTRUCTOR = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NOT_A_CLASS = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory ILLEGAL_ESCAPE_SEQUENCE = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory LOCAL_EXTENSION_PROPERTY = DiagnosticFactory.create(ERROR, "Local extension properties are not allowed"); - DiagnosticFactory LOCAL_VARIABLE_WITH_GETTER = DiagnosticFactory.create(ERROR, "Local variables are not allowed to have getters"); - DiagnosticFactory LOCAL_VARIABLE_WITH_SETTER = DiagnosticFactory.create(ERROR, "Local variables are not allowed to have setters"); - DiagnosticFactory VAL_WITH_SETTER = DiagnosticFactory.create(ERROR, "A 'val'-property cannot have a setter"); + SimpleDiagnosticFactory LOCAL_EXTENSION_PROPERTY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory LOCAL_VARIABLE_WITH_GETTER = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory LOCAL_VARIABLE_WITH_SETTER = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory VAL_WITH_SETTER = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory NO_GET_METHOD = DiagnosticFactory.create(ERROR, "No get method providing array access", PositioningStrategies.POSITION_ARRAY_ACCESS); - DiagnosticFactory NO_SET_METHOD = DiagnosticFactory.create(ERROR, "No set method providing array access", PositioningStrategies.POSITION_ARRAY_ACCESS); + SimpleDiagnosticFactory NO_GET_METHOD = + SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.POSITION_ARRAY_ACCESS); + SimpleDiagnosticFactory NO_SET_METHOD = + SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.POSITION_ARRAY_ACCESS); - DiagnosticFactory INC_DEC_SHOULD_NOT_RETURN_UNIT = DiagnosticFactory.create(ERROR, "Functions inc(), dec() shouldn't return Unit to be used by operators ++, --"); + SimpleDiagnosticFactory INC_DEC_SHOULD_NOT_RETURN_UNIT = SimpleDiagnosticFactory.create(ERROR); DiagnosticFactory2 ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT = - DiagnosticFactory2.create(ERROR, "Function ''{0}'' should return Unit to be used by corresponding operator ''{1}''", NAME, ELEMENT_TEXT); - AmbiguousDescriptorDiagnosticFactory ASSIGN_OPERATOR_AMBIGUITY = AmbiguousDescriptorDiagnosticFactory.create("Assignment operators ambiguity: {0}"); + DiagnosticFactory2.create(ERROR); + AmbiguousDescriptorDiagnosticFactory ASSIGN_OPERATOR_AMBIGUITY = AmbiguousDescriptorDiagnosticFactory.create(); - DiagnosticFactory EQUALS_MISSING = DiagnosticFactory.create(ERROR, "No method 'equals(Any?) : Boolean' available"); - DiagnosticFactory ASSIGNMENT_IN_EXPRESSION_CONTEXT = DiagnosticFactory.create(ERROR, "Assignments are not expressions, and only expressions are allowed in this context"); - DiagnosticFactory NAMESPACE_IS_NOT_AN_EXPRESSION = DiagnosticFactory.create(ERROR, "'namespace' is not an expression, it can only be used on the left-hand side of a dot ('.')"); - DiagnosticFactory1 SUPER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR, "{0} is not an expression, it can only be used on the left-hand side of a dot ('.')"); - DiagnosticFactory DECLARATION_IN_ILLEGAL_CONTEXT = DiagnosticFactory.create(ERROR, "Declarations are not allowed in this position"); - DiagnosticFactory SETTER_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory.create(ERROR, "Setter parameters can not have default values"); - DiagnosticFactory NO_THIS = DiagnosticFactory.create(ERROR, "'this' is not defined in this context"); - DiagnosticFactory SUPER_NOT_AVAILABLE = DiagnosticFactory.create(ERROR, "No supertypes are accessible in this context"); - DiagnosticFactory AMBIGUOUS_SUPER = DiagnosticFactory.create(ERROR, "Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super'"); - DiagnosticFactory ABSTRACT_SUPER_CALL = DiagnosticFactory.create(ERROR, "Abstract member cannot be accessed directly"); - DiagnosticFactory NOT_A_SUPERTYPE = DiagnosticFactory.create(ERROR, "Not a supertype"); - DiagnosticFactory TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER = DiagnosticFactory.create(WARNING, "Type arguments do not need to be specified in a 'super' qualifier"); - DiagnosticFactory USELESS_CAST_STATIC_ASSERT_IS_FINE = DiagnosticFactory.create(WARNING, "No cast needed, use ':' instead"); - DiagnosticFactory USELESS_CAST = DiagnosticFactory.create(WARNING, "No cast needed"); - DiagnosticFactory CAST_NEVER_SUCCEEDS = DiagnosticFactory.create(WARNING, "This cast can never succeed"); - DiagnosticFactory1 WRONG_SETTER_PARAMETER_TYPE = DiagnosticFactory1.create(ERROR, "Setter parameter type must be equal to the type of the property, i.e. {0}", RENDER_TYPE);//, DiagnosticParameters.TYPE); - DiagnosticFactory1 WRONG_GETTER_RETURN_TYPE = DiagnosticFactory1.create(ERROR, "Getter return type must be equal to the type of the property, i.e. {0}", RENDER_TYPE);//, DiagnosticParameters.TYPE); - DiagnosticFactory1 NO_CLASS_OBJECT = DiagnosticFactory1.create(ERROR, "Please specify constructor invocation; classifier {0} does not have a class object", NAME); - DiagnosticFactory NO_GENERICS_IN_SUPERTYPE_SPECIFIER = DiagnosticFactory.create(ERROR, "Generic arguments of the base type must be specified"); + SimpleDiagnosticFactory EQUALS_MISSING = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory ASSIGNMENT_IN_EXPRESSION_CONTEXT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NAMESPACE_IS_NOT_AN_EXPRESSION = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory1 SUPER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactory DECLARATION_IN_ILLEGAL_CONTEXT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SETTER_PARAMETER_WITH_DEFAULT_VALUE = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NO_THIS = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SUPER_NOT_AVAILABLE = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory AMBIGUOUS_SUPER = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory ABSTRACT_SUPER_CALL = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NOT_A_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory USELESS_CAST_STATIC_ASSERT_IS_FINE = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory USELESS_CAST = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory CAST_NEVER_SUCCEEDS = SimpleDiagnosticFactory.create(WARNING); + DiagnosticFactory2 WRONG_SETTER_PARAMETER_TYPE = DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 WRONG_GETTER_RETURN_TYPE = DiagnosticFactory2.create(ERROR); + DiagnosticFactory1 NO_CLASS_OBJECT = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactory NO_GENERICS_IN_SUPERTYPE_SPECIFIER = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY = DiagnosticFactory.create(ERROR, "An ambiguity between 'iterator().hasNext()' function and 'iterator().hasNext' property"); - DiagnosticFactory HAS_NEXT_MISSING = DiagnosticFactory.create(ERROR, "Loop range must have an 'iterator().hasNext()' function or an 'iterator().hasNext' property"); - DiagnosticFactory HAS_NEXT_FUNCTION_AMBIGUITY = DiagnosticFactory.create(ERROR, "Function 'iterator().hasNext()' is ambiguous for this expression"); - DiagnosticFactory HAS_NEXT_MUST_BE_READABLE = DiagnosticFactory.create(ERROR, "The 'iterator().hasNext' property of the loop range must be readable"); - DiagnosticFactory1 HAS_NEXT_PROPERTY_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR, "The 'iterator().hasNext' property of the loop range must return Boolean, but returns {0}", RENDER_TYPE); - DiagnosticFactory1 HAS_NEXT_FUNCTION_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR, "The 'iterator().hasNext()' function of the loop range must return Boolean, but returns {0}", RENDER_TYPE); - DiagnosticFactory NEXT_AMBIGUITY = DiagnosticFactory.create(ERROR, "Function 'iterator().next()' is ambiguous for this expression"); - DiagnosticFactory NEXT_MISSING = DiagnosticFactory.create(ERROR, "Loop range must have an 'iterator().next()' function"); - DiagnosticFactory ITERATOR_MISSING = DiagnosticFactory.create(ERROR, "For-loop range must have an iterator() method"); - AmbiguousDescriptorDiagnosticFactory ITERATOR_AMBIGUITY = AmbiguousDescriptorDiagnosticFactory.create("Method 'iterator()' is ambiguous for this expression: {0}"); + SimpleDiagnosticFactory HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory HAS_NEXT_MISSING = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory HAS_NEXT_FUNCTION_AMBIGUITY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory HAS_NEXT_MUST_BE_READABLE = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory1 HAS_NEXT_PROPERTY_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 HAS_NEXT_FUNCTION_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactory NEXT_AMBIGUITY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NEXT_MISSING = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory ITERATOR_MISSING = SimpleDiagnosticFactory.create(ERROR); + AmbiguousDescriptorDiagnosticFactory ITERATOR_AMBIGUITY = AmbiguousDescriptorDiagnosticFactory.create(); - DiagnosticFactory1 COMPARE_TO_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR, "compareTo() must return Int, but returns {0}", RENDER_TYPE); - DiagnosticFactory1 CALLEE_NOT_A_FUNCTION = DiagnosticFactory1.create(ERROR, "Expecting a function type, but found {0}", RENDER_TYPE); + DiagnosticFactory1 COMPARE_TO_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 CALLEE_NOT_A_FUNCTION = DiagnosticFactory1.create(ERROR); - DiagnosticFactory RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = DiagnosticFactory.create(ERROR, "Returns are not allowed for functions with expression body. Use block body in '{...}'"); - DiagnosticFactory NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY = DiagnosticFactory.create(ERROR, "A 'return' expression required in a function with a block body ('{...}')", new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull JetDeclarationWithBody element) { - JetExpression bodyExpression = element.getBodyExpression(); - if (!(bodyExpression instanceof JetBlockExpression)) return Collections.emptyList(); - JetBlockExpression blockExpression = (JetBlockExpression) bodyExpression; - TextRange lastBracketRange = blockExpression.getLastBracketRange(); - if (lastBracketRange == null) return Collections.emptyList(); - return markRange(lastBracketRange); - } - }); - DiagnosticFactory1 RETURN_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR, "This function must return a value of type {0}", RENDER_TYPE); - DiagnosticFactory1 EXPECTED_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR, "Expected a value of type {0}", RENDER_TYPE); - DiagnosticFactory1 ASSIGNMENT_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR, "Expected a value of type {0}. Assignment operation is not an expression, so it does not return any value", RENDER_TYPE); - DiagnosticFactory1 IMPLICIT_CAST_TO_UNIT_OR_ANY = DiagnosticFactory1.create(WARNING, "Type was casted to ''{0}''. Please specify ''{0}'' as expected type, if you mean such cast", RENDER_TYPE); - DiagnosticFactory1 EXPRESSION_EXPECTED = DiagnosticFactory1.create(ERROR, "{0} is not an expression, and only expression are allowed here", new Renderer() { - @NotNull - @Override - public String render(@Nullable JetExpression expression) { - assert expression != null; - String expressionType = expression.toString(); - return expressionType.substring(0, 1) + expressionType.substring(1).toLowerCase(); - } - }); + SimpleDiagnosticFactory RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY = + SimpleDiagnosticFactory.create(ERROR, + new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull JetDeclarationWithBody element) { + JetExpression bodyExpression = element.getBodyExpression(); + if (!(bodyExpression instanceof JetBlockExpression)) { + return Collections.emptyList(); + } + JetBlockExpression blockExpression = (JetBlockExpression)bodyExpression; + TextRange lastBracketRange = blockExpression.getLastBracketRange(); + if (lastBracketRange == null) { + return Collections.emptyList(); + } + return markRange(lastBracketRange); + } + }); + DiagnosticFactory1 RETURN_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 EXPECTED_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 ASSIGNMENT_TYPE_MISMATCH = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 IMPLICIT_CAST_TO_UNIT_OR_ANY = DiagnosticFactory1.create(WARNING); + DiagnosticFactory1 EXPRESSION_EXPECTED = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 UPPER_BOUND_VIOLATED = DiagnosticFactory1.create(ERROR, "An upper bound {0} is violated", RENDER_TYPE); // TODO : Message - DiagnosticFactory1 FINAL_CLASS_OBJECT_UPPER_BOUND = DiagnosticFactory1.create(ERROR, "{0} is a final type, and thus a class object cannot extend it", RENDER_TYPE); - DiagnosticFactory1 FINAL_UPPER_BOUND = DiagnosticFactory1.create(WARNING, "{0} is a final type, and thus a value of the type parameter is predetermined", RENDER_TYPE); - DiagnosticFactory1 USELESS_ELVIS = DiagnosticFactory1.create(WARNING, "Elvis operator (?:) always returns the left operand of non-nullable type {0}", RENDER_TYPE); - DiagnosticFactory1 CONFLICTING_UPPER_BOUNDS = DiagnosticFactory1.create(ERROR, "Upper bounds of {0} have empty intersection", NAME); - DiagnosticFactory1 CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS = DiagnosticFactory1.create(ERROR, "Class object upper bounds of {0} have empty intersection", NAME); + DiagnosticFactory2 UPPER_BOUND_VIOLATED = DiagnosticFactory2.create(ERROR); + DiagnosticFactory1 FINAL_CLASS_OBJECT_UPPER_BOUND = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 FINAL_UPPER_BOUND = DiagnosticFactory1.create(WARNING); + DiagnosticFactory1 USELESS_ELVIS = DiagnosticFactory1.create(WARNING); + DiagnosticFactory1 CONFLICTING_UPPER_BOUNDS = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 TOO_MANY_ARGUMENTS = DiagnosticFactory1.create(ERROR, "Too many arguments for {0}"); - DiagnosticFactory1 ERROR_COMPILE_TIME_VALUE = DiagnosticFactory1.create(ERROR, "{0}"); + DiagnosticFactory1 TOO_MANY_ARGUMENTS = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 ERROR_COMPILE_TIME_VALUE = DiagnosticFactory1.create(ERROR); - DiagnosticFactory ELSE_MISPLACED_IN_WHEN = DiagnosticFactory.create( - ERROR, "'else' entry must be the last one in a when-expression", new PositioningStrategy() { + SimpleDiagnosticFactory ELSE_MISPLACED_IN_WHEN = SimpleDiagnosticFactory.create(ERROR, new PositioningStrategy() { @NotNull @Override public List mark(@NotNull JetWhenEntry entry) { @@ -291,7 +283,8 @@ public interface Errors { } }); - DiagnosticFactory NO_ELSE_IN_WHEN = new DiagnosticFactory(ERROR, "'when' expression must contain 'else' branch", new PositioningStrategy() { + SimpleDiagnosticFactory + NO_ELSE_IN_WHEN = new SimpleDiagnosticFactory(ERROR, new PositioningStrategy() { @NotNull @Override public List mark(@NotNull JetWhenExpression element) { @@ -299,170 +292,148 @@ public interface Errors { return markElement(element.getWhenKeywordElement()); } }); - DiagnosticFactory TYPE_MISMATCH_IN_RANGE = new DiagnosticFactory(ERROR, "Type mismatch: incompatible types of range and element checked in it", new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull JetWhenConditionInRange condition) { - return markElement(condition.getOperationReference()); - } - }); - DiagnosticFactory CYCLIC_INHERITANCE_HIERARCHY = DiagnosticFactory.create(ERROR, "There's a cycle in the inheritance hierarchy for this type"); + SimpleDiagnosticFactory TYPE_MISMATCH_IN_RANGE = + new SimpleDiagnosticFactory(ERROR, + new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull JetWhenConditionInRange condition) { + return markElement(condition.getOperationReference()); + } + }); + SimpleDiagnosticFactory CYCLIC_INHERITANCE_HIERARCHY = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory MANY_CLASSES_IN_SUPERTYPE_LIST = DiagnosticFactory.create(ERROR, "Only one class may appear in a supertype list"); - DiagnosticFactory SUPERTYPE_NOT_A_CLASS_OR_TRAIT = DiagnosticFactory.create(ERROR, "Only classes and traits may serve as supertypes"); - DiagnosticFactory SUPERTYPE_INITIALIZED_IN_TRAIT = DiagnosticFactory.create(ERROR, "Traits cannot initialize supertypes"); - DiagnosticFactory CONSTRUCTOR_IN_TRAIT = DiagnosticFactory.create(ERROR, "A trait may not have a constructor"); - DiagnosticFactory SECONDARY_CONSTRUCTORS_ARE_NOT_SUPPORTED = DiagnosticFactory.create(WARNING, "Secondary constructors are not supported"); - DiagnosticFactory SUPERTYPE_APPEARS_TWICE = DiagnosticFactory.create(ERROR, "A supertype appears twice"); - DiagnosticFactory FINAL_SUPERTYPE = DiagnosticFactory.create(ERROR, "This type is final, so it cannot be inherited from"); + SimpleDiagnosticFactory MANY_CLASSES_IN_SUPERTYPE_LIST = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SUPERTYPE_NOT_A_CLASS_OR_TRAIT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SUPERTYPE_INITIALIZED_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory CONSTRUCTOR_IN_TRAIT = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory SECONDARY_CONSTRUCTORS_ARE_NOT_SUPPORTED = SimpleDiagnosticFactory.create(WARNING); + SimpleDiagnosticFactory SUPERTYPE_APPEARS_TWICE = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory FINAL_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory1 ILLEGAL_SELECTOR = DiagnosticFactory1.create(ERROR, "Expression ''{0}'' cannot be a selector (occur after a dot)"); + DiagnosticFactory1 ILLEGAL_SELECTOR = DiagnosticFactory1.create(ERROR); - DiagnosticFactory VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = DiagnosticFactory.create(ERROR, "A type annotation is required on a value parameter"); - DiagnosticFactory BREAK_OR_CONTINUE_OUTSIDE_A_LOOP = DiagnosticFactory.create(ERROR, "'break' and 'continue' are only allowed inside a loop"); - DiagnosticFactory1 NOT_A_LOOP_LABEL = DiagnosticFactory1.create(ERROR, "The label ''{0}'' does not denote a loop"); - DiagnosticFactory1 NOT_A_RETURN_LABEL = DiagnosticFactory1.create(ERROR, "The label ''{0}'' does not reference to a context from which we can return"); + SimpleDiagnosticFactory VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory BREAK_OR_CONTINUE_OUTSIDE_A_LOOP = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory1 NOT_A_LOOP_LABEL = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 NOT_A_RETURN_LABEL = DiagnosticFactory1.create(ERROR); - DiagnosticFactory ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR = DiagnosticFactory.create(ERROR, "Anonymous initializers are only allowed in the presence of a primary constructor"); - DiagnosticFactory NULLABLE_SUPERTYPE = DiagnosticFactory.create(ERROR, "A supertype cannot be nullable", new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull JetNullableType element) { - return markNode(element.getQuestionMarkNode()); - } - }); - DiagnosticFactory1 UNSAFE_CALL = DiagnosticFactory1.create(ERROR, "Only safe calls (?.) are allowed on a nullable receiver of type {0}", RENDER_TYPE); - DiagnosticFactory AMBIGUOUS_LABEL = DiagnosticFactory.create(ERROR, "Ambiguous label"); - DiagnosticFactory1 UNSUPPORTED = DiagnosticFactory1.create(ERROR, "Unsupported [{0}]"); - DiagnosticFactory1 UNNECESSARY_SAFE_CALL = DiagnosticFactory1.create(WARNING, "Unnecessary safe call on a non-null receiver of type {0}", RENDER_TYPE); - DiagnosticFactory1 UNNECESSARY_NOT_NULL_ASSERTION = DiagnosticFactory1.create(WARNING, "Unnecessary non-null assertion (!!) on a non-null receiver of type {0}", RENDER_TYPE); - DiagnosticFactory2 NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER = DiagnosticFactory2.create(ERROR, "{0} does not refer to a type parameter of {1}", new Renderer() { - @NotNull - @Override - public String render(@Nullable JetTypeConstraint typeConstraint) { - assert typeConstraint != null; - return typeConstraint.getSubjectTypeParameterName().getReferencedName(); - } - }, NAME); - DiagnosticFactory2 AUTOCAST_IMPOSSIBLE = DiagnosticFactory2.create(ERROR, "Automatic cast to {0} is impossible, because {1} could have changed since the is-check", RENDER_TYPE, NAME); + SimpleDiagnosticFactory ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR = SimpleDiagnosticFactory.create(ERROR); + SimpleDiagnosticFactory NULLABLE_SUPERTYPE = SimpleDiagnosticFactory.create(ERROR, + new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull JetNullableType element) { + return markNode( + element.getQuestionMarkNode()); + } + }); + DiagnosticFactory1 UNSAFE_CALL = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactory AMBIGUOUS_LABEL = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory1 UNSUPPORTED = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 UNNECESSARY_SAFE_CALL = DiagnosticFactory1.create(WARNING); + DiagnosticFactory1 UNNECESSARY_NOT_NULL_ASSERTION = DiagnosticFactory1.create(WARNING); + DiagnosticFactory2 NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER = + DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 AUTOCAST_IMPOSSIBLE = DiagnosticFactory2.create(ERROR); - DiagnosticFactory2 TYPE_MISMATCH_IN_FOR_LOOP = DiagnosticFactory2.create(ERROR, "The loop iterates over values of type {0} but the parameter is declared to be {1}", RENDER_TYPE, RENDER_TYPE); - DiagnosticFactory1 TYPE_MISMATCH_IN_CONDITION = DiagnosticFactory1.create(ERROR, "Condition must be of type Boolean, but was of type {0}", RENDER_TYPE); - DiagnosticFactory2 TYPE_MISMATCH_IN_TUPLE_PATTERN = DiagnosticFactory2.create(ERROR, "Type mismatch: subject is of type {0} but the pattern is of type Tuple{1}", RENDER_TYPE, TO_STRING); // TODO: message - DiagnosticFactory2 TYPE_MISMATCH_IN_BINDING_PATTERN = DiagnosticFactory2.create(ERROR, "{0} must be a supertype of {1}. Use 'is' to match against {0}", RENDER_TYPE, RENDER_TYPE); - DiagnosticFactory2 INCOMPATIBLE_TYPES = DiagnosticFactory2.create(ERROR, "Incompatible types: {0} and {1}", RENDER_TYPE, RENDER_TYPE); - DiagnosticFactory EXPECTED_CONDITION = DiagnosticFactory.create(ERROR, "Expected condition of Boolean type"); + DiagnosticFactory2 TYPE_MISMATCH_IN_FOR_LOOP = DiagnosticFactory2.create(ERROR); + DiagnosticFactory1 TYPE_MISMATCH_IN_CONDITION = DiagnosticFactory1.create(ERROR); + DiagnosticFactory2 TYPE_MISMATCH_IN_TUPLE_PATTERN = DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 TYPE_MISMATCH_IN_BINDING_PATTERN = DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 INCOMPATIBLE_TYPES = DiagnosticFactory2.create(ERROR); + SimpleDiagnosticFactory EXPECTED_CONDITION = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory1 CANNOT_CHECK_FOR_ERASED = DiagnosticFactory1.create(ERROR, "Cannot check for instance of erased type: {0}", RENDER_TYPE); - DiagnosticFactory2 UNCHECKED_CAST = DiagnosticFactory2.create(WARNING, "Unchecked cast: {0} to {1}", RENDER_TYPE, RENDER_TYPE); + DiagnosticFactory1 CANNOT_CHECK_FOR_ERASED = DiagnosticFactory1.create(ERROR); + DiagnosticFactory2 UNCHECKED_CAST = DiagnosticFactory2.create(WARNING); - DiagnosticFactory3> INCONSISTENT_TYPE_PARAMETER_VALUES = - DiagnosticFactory3.create(ERROR, "Type parameter {0} of {1} has inconsistent values: {2}", NAME, DescriptorRenderer.TEXT, new Renderer>() { + DiagnosticFactory3> + INCONSISTENT_TYPE_PARAMETER_VALUES = DiagnosticFactory3.create(ERROR); + + DiagnosticFactory3 EQUALITY_NOT_APPLICABLE = + DiagnosticFactory3.create(ERROR); + + DiagnosticFactory2 SENSELESS_COMPARISON = DiagnosticFactory2.create(WARNING); + + DiagnosticFactory2 OVERRIDING_FINAL_MEMBER = + DiagnosticFactory2.create(ERROR); + DiagnosticFactory3 CANNOT_WEAKEN_ACCESS_PRIVILEGE = + DiagnosticFactory3.create(ERROR, PositioningStrategies.POSITION_VISIBILITY_MODIFIER); + DiagnosticFactory3 CANNOT_CHANGE_ACCESS_PRIVILEGE = + DiagnosticFactory3.create(ERROR, PositioningStrategies.POSITION_VISIBILITY_MODIFIER); + + DiagnosticFactory2 RETURN_TYPE_MISMATCH_ON_OVERRIDE = + DiagnosticFactory2.create(ERROR, PositioningStrategies.POSITION_DECLARATION); + + DiagnosticFactory2 VAR_OVERRIDDEN_BY_VAL = + DiagnosticFactory2.create(ERROR, new PositioningStrategy() { @NotNull @Override - public String render(@Nullable Collection types) { - StringBuilder builder = new StringBuilder(); - for (Iterator iterator = types.iterator(); iterator.hasNext(); ) { - JetType jetType = iterator.next(); - builder.append(jetType); - if (iterator.hasNext()) { - builder.append(", "); - } - } - return builder.toString(); + public List mark(@NotNull JetProperty property) { + return markNode(property.getValOrVarNode()); } }); - DiagnosticFactory3 EQUALITY_NOT_APPLICABLE = DiagnosticFactory3.create(ERROR, "Operator {0} cannot be applied to {1} and {2}", new Renderer() { - @NotNull - @Override - public String render(@Nullable JetSimpleNameExpression nameExpression) { - return nameExpression.getReferencedName(); - } - }, TO_STRING, TO_STRING); + DiagnosticFactory2 ABSTRACT_MEMBER_NOT_IMPLEMENTED = + DiagnosticFactory2.create(ERROR); - DiagnosticFactory2 SENSELESS_COMPARISON = DiagnosticFactory2.create(WARNING, "Condition ''{0}'' is always ''{1}''", ELEMENT_TEXT, TO_STRING); + DiagnosticFactory2 MANY_IMPL_MEMBER_NOT_IMPLEMENTED = + DiagnosticFactory2.create(ERROR); - DiagnosticFactory2 OVERRIDING_FINAL_MEMBER = DiagnosticFactory2.create(ERROR, "''{0}'' in ''{1}'' is final and cannot be overridden", NAME, NAME); - DiagnosticFactory3 CANNOT_WEAKEN_ACCESS_PRIVILEGE = DiagnosticFactory3.create(ERROR, "Cannot weaken access privilege ''{0}'' for ''{1}'' in ''{2}''", PositioningStrategies.POSITION_VISIBILITY_MODIFIER, TO_STRING, NAME, NAME); - DiagnosticFactory3 CANNOT_CHANGE_ACCESS_PRIVILEGE = DiagnosticFactory3.create(ERROR, "Cannot change access privilege ''{0}'' for ''{1}'' in ''{2}''", PositioningStrategies.POSITION_VISIBILITY_MODIFIER, TO_STRING, NAME, NAME); - - DiagnosticFactory2 RETURN_TYPE_MISMATCH_ON_OVERRIDE = - DiagnosticFactory2.create(ERROR, "Return type of {0} is not a subtype of the return type overridden member {1}", PositioningStrategies.POSITION_DECLARATION, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); - - DiagnosticFactory2 VAR_OVERRIDDEN_BY_VAL = DiagnosticFactory2.create(ERROR, "Var-property {0} cannot be overridden by val-property {1}", new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull JetProperty property) { - return markNode(property.getValOrVarNode()); - } - }, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); - - DiagnosticFactory2 ABSTRACT_MEMBER_NOT_IMPLEMENTED = DiagnosticFactory2.create(ERROR, "{0} must be declared abstract or implement abstract member {1}", RENDER_CLASS_OR_OBJECT, DescriptorRenderer.TEXT); - - DiagnosticFactory2 MANY_IMPL_MEMBER_NOT_IMPLEMENTED = DiagnosticFactory2.create(ERROR, "{0} must override {1} because it inherits many implementations of it", RENDER_CLASS_OR_OBJECT, DescriptorRenderer.TEXT); - - DiagnosticFactory2 CONFLICTING_OVERLOADS = DiagnosticFactory2.create(ERROR, "{1} is already defined in ''{0}''", new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull JetDeclaration jetDeclaration) { - if (jetDeclaration instanceof JetNamedFunction) { - JetNamedFunction functionElement = (JetNamedFunction) jetDeclaration; - return markRange(new TextRange( - functionElement.getStartOfSignatureElement().getTextRange().getStartOffset(), - functionElement.getEndOfSignatureElement().getTextRange().getEndOffset() - )); - } - else if (jetDeclaration instanceof JetClass) { - // primary constructor - JetClass klass = (JetClass) jetDeclaration; - PsiElement nameAsDeclaration = klass.getNameIdentifier(); - if (nameAsDeclaration == null) { - return markRange(klass.getTextRange()); + DiagnosticFactory2 CONFLICTING_OVERLOADS = + DiagnosticFactory2.create(ERROR, new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull JetDeclaration jetDeclaration) { + if (jetDeclaration instanceof JetNamedFunction) { + JetNamedFunction functionElement = (JetNamedFunction)jetDeclaration; + return markRange(new TextRange( + functionElement.getStartOfSignatureElement().getTextRange().getStartOffset(), + functionElement.getEndOfSignatureElement().getTextRange().getEndOffset() + )); + } + else if (jetDeclaration instanceof JetClass) { + // primary constructor + JetClass klass = (JetClass)jetDeclaration; + PsiElement nameAsDeclaration = klass.getNameIdentifier(); + if (nameAsDeclaration == null) { + return markRange(klass.getTextRange()); + } + PsiElement primaryConstructorParameterList = klass.getPrimaryConstructorParameterList(); + if (primaryConstructorParameterList == null) { + return markRange(nameAsDeclaration.getTextRange()); + } + return markRange(new TextRange( + nameAsDeclaration.getTextRange().getStartOffset(), + primaryConstructorParameterList.getTextRange().getEndOffset() + )); + } + else { + // safe way + return markRange(jetDeclaration.getTextRange()); + } } - PsiElement primaryConstructorParameterList = klass.getPrimaryConstructorParameterList(); - if (primaryConstructorParameterList == null) { - return markRange(nameAsDeclaration.getTextRange()); - } - return markRange(new TextRange( - nameAsDeclaration.getTextRange().getStartOffset(), - primaryConstructorParameterList.getTextRange().getEndOffset() - )); - } - else { - // safe way - return markRange(jetDeclaration.getTextRange()); - } - } - }, DescriptorRenderer.TEXT, TO_STRING); + }); - DiagnosticFactory3 RESULT_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR, "{0} must return {1} but returns {2}", TO_STRING, RENDER_TYPE, RENDER_TYPE); - DiagnosticFactory3 UNSAFE_INFIX_CALL = DiagnosticFactory3.create(ERROR, "Infix call corresponds to a dot-qualified call ''{0}.{1}({2})'' which is not allowed on a nullable receiver ''{0}''. Use '?.'-qualified call instead"); + DiagnosticFactory3 RESULT_TYPE_MISMATCH = DiagnosticFactory3.create(ERROR); + DiagnosticFactory3 UNSAFE_INFIX_CALL = DiagnosticFactory3.create(ERROR); - AmbiguousDescriptorDiagnosticFactory OVERLOAD_RESOLUTION_AMBIGUITY = new AmbiguousDescriptorDiagnosticFactory("Overload resolution ambiguity: {0}"); - AmbiguousDescriptorDiagnosticFactory NONE_APPLICABLE = new AmbiguousDescriptorDiagnosticFactory("None of the following functions can be called with the arguments supplied: {0}"); - DiagnosticFactory1 NO_VALUE_FOR_PARAMETER = DiagnosticFactory1.create(ERROR, "No value passed for parameter {0}", DescriptorRenderer.TEXT); - DiagnosticFactory1 MISSING_RECEIVER = DiagnosticFactory1.create(ERROR, "A receiver of type {0} is required", RENDER_TYPE); - DiagnosticFactory NO_RECEIVER_ADMITTED = DiagnosticFactory.create(ERROR, "No receiver can be passed to this function or property"); + AmbiguousDescriptorDiagnosticFactory OVERLOAD_RESOLUTION_AMBIGUITY = new AmbiguousDescriptorDiagnosticFactory(); + AmbiguousDescriptorDiagnosticFactory NONE_APPLICABLE = new AmbiguousDescriptorDiagnosticFactory(); + DiagnosticFactory1 NO_VALUE_FOR_PARAMETER = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 MISSING_RECEIVER = DiagnosticFactory1.create(ERROR); + SimpleDiagnosticFactory NO_RECEIVER_ADMITTED = SimpleDiagnosticFactory.create(ERROR); - DiagnosticFactory CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS = DiagnosticFactory.create(ERROR, "Can not create an instance of an abstract class"); - DiagnosticFactory1 TYPE_INFERENCE_FAILED = DiagnosticFactory1.create(ERROR, "Type inference failed: {0}"); - DiagnosticFactory1 WRONG_NUMBER_OF_TYPE_ARGUMENTS = DiagnosticFactory1.create(ERROR, "{0} type arguments expected", new Renderer() { - @NotNull - @Override - public String render(@Nullable Integer argument) { - assert argument != null; - return argument == 0 ? "No" : argument.toString(); - } - }); + SimpleDiagnosticFactory CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS = SimpleDiagnosticFactory.create(ERROR); + DiagnosticFactory1 TYPE_INFERENCE_FAILED = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 WRONG_NUMBER_OF_TYPE_ARGUMENTS = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 UNRESOLVED_IDE_TEMPLATE = DiagnosticFactory1.create(ERROR, "Unresolved IDE template: {0}"); + DiagnosticFactory1 UNRESOLVED_IDE_TEMPLATE = DiagnosticFactory1.create(ERROR); - DiagnosticFactory DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED = DiagnosticFactory.create(WARNING, "This expression is treated as an argument to the function call on the previous line. " + - "Separate it with a semicolon (;) if it is not intended to be an argument."); + SimpleDiagnosticFactory DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED = SimpleDiagnosticFactory.create(WARNING); - DiagnosticFactory1 NOT_AN_ANNOTATION_CLASS = DiagnosticFactory1.create(ERROR, "{0} is not an annotation class"); + DiagnosticFactory1 NOT_AN_ANNOTATION_CLASS = DiagnosticFactory1.create(ERROR); // This field is needed to make the Initializer class load (interfaces cannot have static initializers) @@ -476,10 +447,11 @@ public interface Errors { try { Object value = field.get(null); if (value instanceof AbstractDiagnosticFactory) { - AbstractDiagnosticFactory factory = (AbstractDiagnosticFactory) value; + AbstractDiagnosticFactory factory = (AbstractDiagnosticFactory)value; factory.setName(field.getName()); } - } catch (IllegalAccessException e) { + } + catch (IllegalAccessException e) { throw new IllegalStateException(e); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java index 96bf5fffeea..21746e40652 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lexer.JetKeywordToken; import org.jetbrains.jet.lexer.JetTokens; +import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -135,4 +136,12 @@ public class PositioningStrategies { return result; } }; + + public static PositioningStrategy PROJECTION_MODIFIER = new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull JetTypeProjection element) { + return markNode(element.getProjectionNode()); + } + }; } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java deleted file mode 100644 index 33553f9ccdd..00000000000 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * 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.lang.diagnostics; - -import com.intellij.openapi.util.TextRange; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetNamedDeclaration; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingContextUtils; - -import java.util.List; - -/** - * @author abreslav - */ -public interface RedeclarationDiagnostic extends Diagnostic { - class SimpleRedeclarationDiagnostic extends AbstractDiagnostic implements RedeclarationDiagnostic { - - public SimpleRedeclarationDiagnostic(@NotNull PsiElement psiElement, @NotNull String name, RedeclarationDiagnosticFactory factory) { - super(psiElement, factory, factory.severity, factory.makeMessage(name)); - } - - @NotNull - @Override - public List getTextRanges() { - return POSITION_REDECLARATION.mark(getPsiElement()); - } - } - - class RedeclarationDiagnosticWithDeferredResolution implements RedeclarationDiagnostic { - - private final DeclarationDescriptor duplicatingDescriptor; - private final BindingContext contextToResolveToDeclaration; - private final RedeclarationDiagnosticFactory factory; - private PsiElement element; - - public RedeclarationDiagnosticWithDeferredResolution(@NotNull DeclarationDescriptor duplicatingDescriptor, @NotNull BindingContext contextToResolveToDeclaration, RedeclarationDiagnosticFactory factory) { - this.duplicatingDescriptor = duplicatingDescriptor; - this.contextToResolveToDeclaration = contextToResolveToDeclaration; - this.factory = factory; - } - - private PsiElement resolve() { - if (element == null) { - element = BindingContextUtils.descriptorToDeclaration(contextToResolveToDeclaration, duplicatingDescriptor); - assert element != null : "No element for descriptor: " + duplicatingDescriptor; - } - return element; - } - - @NotNull - @Override - public PsiElement getPsiElement() { - return resolve(); - } - - @NotNull - @Override - public List getTextRanges() { - return POSITION_REDECLARATION.mark(getPsiElement()); - } - - @NotNull - @Override - public PsiFile getPsiFile() { - return resolve().getContainingFile(); - } - - @NotNull - @Override - public AbstractDiagnosticFactory getFactory() { - return factory; - } - - @NotNull - @Override - public String getMessage() { - return factory.makeMessage(duplicatingDescriptor.getName()); - } - - @NotNull - @Override - public Severity getSeverity() { - return factory.severity; - } - } - - PositioningStrategy POSITION_REDECLARATION = new PositioningStrategy() { - @NotNull - @Override - public List mark(@NotNull PsiElement element) { - if (element instanceof JetNamedDeclaration) { - PsiElement nameIdentifier = ((JetNamedDeclaration) element).getNameIdentifier(); - if (nameIdentifier != null) { - return markElement(nameIdentifier); - } - } - else if (element instanceof JetFile) { - JetFile file = (JetFile) element; - PsiElement nameIdentifier = file.getNamespaceHeader().getNameIdentifier(); - if (nameIdentifier != null) { - return markElement(nameIdentifier); - } - } - return markElement(element); - } - }; -} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java index 053238f2839..023a7e8c077 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java @@ -16,45 +16,40 @@ package org.jetbrains.jet.lang.diagnostics; +import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetNamedDeclaration; + +import java.util.List; /** * @author abreslav */ -public class RedeclarationDiagnosticFactory extends AbstractDiagnosticFactory { - - private final String name; - final Severity severity; - private final String messagePrefix; +public class RedeclarationDiagnosticFactory extends DiagnosticFactory1 { + private static final PositioningStrategy POSITION_REDECLARATION = new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull PsiElement element) { + if (element instanceof JetNamedDeclaration) { + PsiElement nameIdentifier = ((JetNamedDeclaration) element).getNameIdentifier(); + if (nameIdentifier != null) { + return markElement(nameIdentifier); + } + } + else if (element instanceof JetFile) { + JetFile file = (JetFile) element; + PsiElement nameIdentifier = file.getNamespaceHeader().getNameIdentifier(); + if (nameIdentifier != null) { + return markElement(nameIdentifier); + } + } + return markElement(element); + } + }; - public static final RedeclarationDiagnosticFactory REDECLARATION = new RedeclarationDiagnosticFactory( - "REDECLARATION", Severity.ERROR, "Redeclaration: "); - public static final RedeclarationDiagnosticFactory NAME_SHADOWING = new RedeclarationDiagnosticFactory( - "NAME_SHADOWING", Severity.WARNING, "Name shadowed: "); - - public RedeclarationDiagnosticFactory(String name, Severity severity, String messagePrefix) { - this.name = name; - this.severity = severity; - this.messagePrefix = messagePrefix; - } - - public RedeclarationDiagnostic on(@NotNull PsiElement duplicatingElement, @NotNull String name) { - return new RedeclarationDiagnostic.SimpleRedeclarationDiagnostic(duplicatingElement, name, this); - } - - @NotNull - @Override - public String getName() { - return name; - } - - public String makeMessage(String identifier) { - return messagePrefix + identifier; - } - - @Override - public String toString() { - return getName(); + public RedeclarationDiagnosticFactory(Severity severity) { + super(severity, POSITION_REDECLARATION); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnostic.java similarity index 68% rename from compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java rename to compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnostic.java index a73ce08470a..5dbaf4f5123 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnostic.java @@ -25,17 +25,20 @@ import java.util.List; /** * @author svtk */ -public class DiagnosticWithPsiElement extends AbstractDiagnostic { - public DiagnosticWithPsiElement(@NotNull E psiElement, @NotNull DiagnosticFactoryWithPsiElement factory, @NotNull Severity severity, @NotNull String message) { - super(psiElement, factory, severity, message); +public class SimpleDiagnostic extends AbstractDiagnostic { + public SimpleDiagnostic(@NotNull E psiElement, + @NotNull SimpleDiagnosticFactory factory, + @NotNull Severity severity) { + super(psiElement, factory, severity); } @NotNull @Override - public DiagnosticFactoryWithPsiElement getFactory() { - return (DiagnosticFactoryWithPsiElement)super.getFactory(); + public SimpleDiagnosticFactory getFactory() { + return (SimpleDiagnosticFactory)super.getFactory(); } + @Override @NotNull public List getTextRanges() { return getFactory().getTextRanges(this); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactory.java new file mode 100644 index 00000000000..8b24829e98f --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactory.java @@ -0,0 +1,43 @@ +/* + * 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.lang.diagnostics; + +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; + +/** + * @author svtk + */ +public class SimpleDiagnosticFactory extends DiagnosticFactoryWithPsiElement { + + protected SimpleDiagnosticFactory(Severity severity, PositioningStrategy positioningStrategy) { + super(severity, positioningStrategy); + } + + public static SimpleDiagnosticFactory create(Severity severity) { + return create(severity, PositioningStrategies.DEFAULT); + } + + public static SimpleDiagnosticFactory create(Severity severity, PositioningStrategy positioningStrategy) { + return new SimpleDiagnosticFactory(severity, positioningStrategy); + } + + @NotNull + public SimpleDiagnostic on(@NotNull E element) { + return new SimpleDiagnostic(element, this, severity); + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java index ddec486cf56..fd80049556d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java @@ -17,30 +17,35 @@ package org.jetbrains.jet.lang.diagnostics; import com.intellij.openapi.util.TextRange; -import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetArrayAccessExpression; import org.jetbrains.jet.lang.psi.JetReferenceExpression; -import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; +import java.util.Collections; import java.util.List; /** * @author abreslav */ -public class UnresolvedReferenceDiagnosticFactory extends AbstractDiagnosticFactory { - - private final String message; - - private UnresolvedReferenceDiagnosticFactory(String message) { - this.message = message; +public class UnresolvedReferenceDiagnosticFactory extends DiagnosticFactory1 { + public UnresolvedReferenceDiagnosticFactory() { + super(Severity.ERROR, new PositioningStrategy() { + @NotNull + @Override + public List mark(@NotNull JetReferenceExpression element) { + if (element instanceof JetArrayAccessExpression) { + return ((JetArrayAccessExpression) element).getBracketRanges(); + } + return Collections.singletonList(element.getTextRange()); + } + }); } - public UnresolvedReferenceDiagnostic on(@NotNull JetReferenceExpression reference) { - return new UnresolvedReferenceDiagnostic(reference, message); + public DiagnosticWithParameters1 on(@NotNull JetReferenceExpression reference) { + return new DiagnosticWithParameters1(reference, reference.getText(), this, severity); } - public static UnresolvedReferenceDiagnosticFactory create(String message) { - return new UnresolvedReferenceDiagnosticFactory(message); + public static UnresolvedReferenceDiagnosticFactory create() { + return new UnresolvedReferenceDiagnosticFactory(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java index 19a297fd9be..a9c8ce304dd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java @@ -17,27 +17,20 @@ package org.jetbrains.jet.lang.diagnostics; import com.intellij.psi.PsiElement; + /** * @author svtk */ public class UnusedElementDiagnosticFactory extends DiagnosticFactory1 { - private UnusedElementDiagnosticFactory(Severity severity, String message, PositioningStrategy positioningStrategy, Renderer renderer) { - super(severity, message, positioningStrategy, renderer); + private UnusedElementDiagnosticFactory(Severity severity, PositioningStrategy positioningStrategy) { + super(severity, positioningStrategy); } - public static UnusedElementDiagnosticFactory create(Severity severity, String message, PositioningStrategy positioningStrategy, Renderer renderer) { - return new UnusedElementDiagnosticFactory(severity, message, positioningStrategy, renderer); + public static UnusedElementDiagnosticFactory create(Severity severity, PositioningStrategy positioningStrategy) { + return new UnusedElementDiagnosticFactory(severity, positioningStrategy); } - public static UnusedElementDiagnosticFactory create(Severity severity, String message, PositioningStrategy positioningStrategy) { - return create(severity, message, positioningStrategy, Renderers.TO_STRING); - } - - public static UnusedElementDiagnosticFactory create(Severity severity, String message, Renderer renderer) { - return create(severity, message, PositioningStrategies.DEFAULT, renderer); - } - - public static UnusedElementDiagnosticFactory create(Severity severity, String message) { - return create(severity, message, PositioningStrategies.DEFAULT, Renderers.TO_STRING); + public static UnusedElementDiagnosticFactory create(Severity severity) { + return create(severity, PositioningStrategies.DEFAULT); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java new file mode 100644 index 00000000000..fd304e115d7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java @@ -0,0 +1,393 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; +import org.jetbrains.jet.lang.psi.JetTypeConstraint; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lexer.JetKeywordToken; +import org.jetbrains.jet.resolve.DescriptorRenderer; + +import java.util.Collection; +import java.util.Iterator; + +import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.*; +import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.RENDER_TYPE; +import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.TO_STRING; + +/** + * @author Evgeny Gerashchenko + * @since 4/13/12 + */ +public class DefaultErrorMessages { + public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap(); + public static final DiagnosticRenderer RENDERER = new DispatchingDiagnosticRenderer(MAP); + + static { + MAP.put(EXCEPTION_WHILE_ANALYZING, "{0}", new Renderer() { + @NotNull + @Override + public String render(@NotNull Throwable e) { + return e.getClass().getSimpleName() + ": " + e.getMessage(); + } + }); + + MAP.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", TO_STRING); + + MAP.put(INVISIBLE_REFERENCE, "Cannot access ''{0}'' in ''{1}''", NAME, NAME); + MAP.put(INVISIBLE_MEMBER, "Cannot access ''{0}'' in ''{1}''", NAME, NAME); + + MAP.put(REDECLARATION, "Redeclaration: {0}", NAME); + MAP.put(NAME_SHADOWING, "Name shadowed: {0}", NAME); + + MAP.put(TYPE_MISMATCH, "Type mismatch: inferred type is {1} but {0} was expected", RENDER_TYPE, RENDER_TYPE); + MAP.put(INCOMPATIBLE_MODIFIERS, "Incompatible modifiers: ''{0}''", new Renderer>() { + @NotNull + @Override + public String render(@NotNull Collection tokens) { + StringBuilder sb = new StringBuilder(); + for (JetKeywordToken token : tokens) { + if (sb.length() != 0) { + sb.append(" "); + } + sb.append(token.getValue()); + } + return sb.toString(); + } + }); + MAP.put(ILLEGAL_MODIFIER, "Illegal modifier ''{0}''", TO_STRING); + + MAP.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", TO_STRING, TO_STRING); + MAP.put(ABSTRACT_MODIFIER_IN_TRAIT, "Modifier ''abstract'' is redundant in trait"); + MAP.put(OPEN_MODIFIER_IN_TRAIT, "Modifier ''open'' is redundant in trait"); + MAP.put(REDUNDANT_MODIFIER_IN_GETTER, "Visibility modifiers are redundant in getter"); + MAP.put(TRAIT_CAN_NOT_BE_FINAL, "Trait cannot be final"); + MAP.put(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, + "Type checking has run into a recursive problem. Easiest workaround: specify types of your declarations explicitly"); // TODO: message + MAP.put(RETURN_NOT_ALLOWED, "'return' is not allowed here"); + MAP.put(PROJECTION_IN_IMMEDIATE_ARGUMENT_TO_SUPERTYPE, "Projections are not allowed for immediate arguments of a supertype"); + MAP.put(LABEL_NAME_CLASH, "There is more than one label with such a name in this scope"); + MAP.put(EXPRESSION_EXPECTED_NAMESPACE_FOUND, "Expression expected, but a namespace name found"); + + MAP.put(CANNOT_IMPORT_FROM_ELEMENT, "Cannot import from ''{0}''", NAME); + MAP.put(CANNOT_BE_IMPORTED, "Cannot import ''{0}'', functions and properties can be imported only from packages", NAME); + MAP.put(USELESS_HIDDEN_IMPORT, "Useless import, it is hidden further"); + MAP.put(USELESS_SIMPLE_IMPORT, "Useless import, does nothing"); + + MAP.put(CANNOT_INFER_PARAMETER_TYPE, + "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation"); + + MAP.put(NO_BACKING_FIELD_ABSTRACT_PROPERTY, "This property doesn't have a backing field, because it's abstract"); + MAP.put(NO_BACKING_FIELD_CUSTOM_ACCESSORS, + "This property doesn't have a backing field, because it has custom accessors without reference to the backing field"); + MAP.put(INACCESSIBLE_BACKING_FIELD, "The backing field is not accessible here"); + MAP.put(NOT_PROPERTY_BACKING_FIELD, "The referenced variable is not a property and doesn't have backing field"); + + MAP.put(MIXING_NAMED_AND_POSITIONED_ARGUMENTS, "Mixing named and positioned arguments in not allowed"); + MAP.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter"); + MAP.put(NAMED_PARAMETER_NOT_FOUND, "Cannot find a parameter with this name: {0}", TO_STRING); + MAP.put(VARARG_OUTSIDE_PARENTHESES, "Passing value as a vararg is only allowed inside a parenthesized argument list"); + MAP.put(NON_VARARG_SPREAD, "The spread operator (*foo) may only be applied in a vararg position"); + + MAP.put(MANY_FUNCTION_LITERAL_ARGUMENTS, "Only one function literal is allowed outside a parenthesized argument list"); + MAP.put(PROPERTY_WITH_NO_TYPE_NO_INITIALIZER, "This property must either have a type annotation or be initialized"); + + MAP.put(ABSTRACT_PROPERTY_IN_PRIMARY_CONSTRUCTOR_PARAMETERS, "This property cannot be declared abstract"); + MAP.put(ABSTRACT_PROPERTY_NOT_IN_CLASS, "A property may be abstract only when defined in a class or trait"); + MAP.put(ABSTRACT_PROPERTY_WITH_INITIALIZER, "Property with initializer cannot be abstract"); + MAP.put(ABSTRACT_PROPERTY_WITH_GETTER, "Property with getter implementation cannot be abstract"); + MAP.put(ABSTRACT_PROPERTY_WITH_SETTER, "Property with setter implementation cannot be abstract"); + + MAP.put(PACKAGE_MEMBER_CANNOT_BE_PROTECTED, "Package member cannot be protected"); + + MAP.put(GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY, "Getter visibility must be the same as property visibility"); + MAP.put(BACKING_FIELD_IN_TRAIT, "Property in a trait cannot have a backing field"); + MAP.put(MUST_BE_INITIALIZED, "Property must be initialized"); + MAP.put(MUST_BE_INITIALIZED_OR_BE_ABSTRACT, "Property must be initialized or be abstract"); + MAP.put(PROPERTY_INITIALIZER_IN_TRAIT, "Property initializers are not allowed in traits"); + MAP.put(PROPERTY_INITIALIZER_NO_BACKING_FIELD, "Initializer is not allowed here because this property has no backing field"); + MAP.put(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS, "Abstract property ''{0}'' in non-abstract class ''{1}''", NAME, NAME); + MAP.put(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, "Abstract function ''{0}'' in non-abstract class ''{1}''", NAME, NAME); + MAP.put(ABSTRACT_FUNCTION_WITH_BODY, "A function ''{0}'' with body cannot be abstract", NAME); + MAP.put(NON_ABSTRACT_FUNCTION_WITH_NO_BODY, "Function ''{0}'' without a body must be abstract", NAME); + MAP.put(NON_MEMBER_ABSTRACT_FUNCTION, "Function ''{0}'' is not a class or trait member and cannot be abstract", NAME); + + MAP.put(NON_MEMBER_FUNCTION_NO_BODY, "Function ''{0}'' must have a body", NAME); + MAP.put(NON_FINAL_MEMBER_IN_FINAL_CLASS, "Non-final member in a final class"); + + MAP.put(PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE, "Public or protected member should have specified type"); + + MAP.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, "Projections are not allowed on type arguments of functions and properties"); + MAP.put(SUPERTYPE_NOT_INITIALIZED, "This type has a constructor, and thus must be initialized here"); + MAP.put(SUPERTYPE_NOT_INITIALIZED_DEFAULT, "Constructor invocation should be explicitly specified"); + MAP.put(SECONDARY_CONSTRUCTOR_BUT_NO_PRIMARY, "A secondary constructor may appear only in a class that has a primary constructor"); + MAP.put(SECONDARY_CONSTRUCTOR_NO_INITIALIZER_LIST, "Secondary constructors must have an initializer list"); + MAP.put(BY_IN_SECONDARY_CONSTRUCTOR, "'by'-clause is only supported for primary constructors"); + MAP.put(INITIALIZER_WITH_NO_ARGUMENTS, "Constructor arguments required"); + MAP.put(MANY_CALLS_TO_THIS, "Only one call to 'this(...)' is allowed"); + MAP.put(NOTHING_TO_OVERRIDE, "''{0}'' overrides nothing", NAME); + MAP.put(VIRTUAL_MEMBER_HIDDEN, "''{0}'' hides member of supertype ''{2}'' and needs ''override'' modifier", NAME, NAME, NAME); + + MAP.put(CANNOT_OVERRIDE_INVISIBLE_MEMBER, "''{0}'' cannot has no access to ''{1}'' in class {2}, so it cannot override it", + DescriptorRenderer.TEXT, DescriptorRenderer.TEXT, DescriptorRenderer.TEXT); + MAP.put(CANNOT_INFER_VISIBILITY, "Cannot infer visibility. Please specify it explicitly"); + + MAP.put(ENUM_ENTRY_SHOULD_BE_INITIALIZED, "Missing delegation specifier ''{0}''", NAME); + MAP.put(ENUM_ENTRY_ILLEGAL_TYPE, "The type constructor of enum entry should be ''{0}''", NAME); + + MAP.put(UNINITIALIZED_VARIABLE, "Variable ''{0}'' must be initialized", NAME); + MAP.put(UNINITIALIZED_PARAMETER, "Parameter ''{0}'' is uninitialized here", NAME); + MAP.put(UNUSED_VARIABLE, "Variable ''{0}'' is never used", NAME); + MAP.put(UNUSED_PARAMETER, "Parameter ''{0}'' is never used", NAME); + MAP.put(ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE, "Variable ''{0}'' is assigned but never accessed", NAME); + MAP.put(VARIABLE_WITH_REDUNDANT_INITIALIZER, "Variable ''{0}'' initializer is redundant", NAME); + MAP.put(UNUSED_VALUE, "The value ''{0}'' assigned to ''{1}'' is never used", ELEMENT_TEXT, TO_STRING); + MAP.put(UNUSED_CHANGED_VALUE, "The value changed at ''{0}'' is never used", ELEMENT_TEXT); + MAP.put(UNUSED_EXPRESSION, "The expression is unused"); + MAP.put(UNUSED_FUNCTION_LITERAL, "The function literal is unused. If you mean block, you can use 'run { ... }'"); + + MAP.put(VAL_REASSIGNMENT, "Val cannot be reassigned", NAME); + MAP.put(INITIALIZATION_BEFORE_DECLARATION, "Variable cannot be initialized before declaration", NAME); + MAP.put(VARIABLE_EXPECTED, "Variable expected"); + + MAP.put(INITIALIZATION_USING_BACKING_FIELD_CUSTOM_SETTER, + "This property has a custom setter, so initialization using backing field required", NAME); + MAP.put(INITIALIZATION_USING_BACKING_FIELD_OPEN_SETTER, + "Setter of this property can be overridden, so initialization using backing field required", NAME); + + MAP.put(FUNCTION_PARAMETERS_OF_INLINE_FUNCTION, "Function parameters of inline function can only be invoked", NAME); + + MAP.put(UNREACHABLE_CODE, "Unreachable code"); + + MAP.put(MANY_CLASS_OBJECTS, "Only one class object is allowed per class"); + MAP.put(CLASS_OBJECT_NOT_ALLOWED, "A class object is not allowed here"); + MAP.put(DELEGATION_IN_TRAIT, "Traits cannot use delegation"); + MAP.put(DELEGATION_NOT_TO_TRAIT, "Only traits can be delegated to"); + MAP.put(NO_CONSTRUCTOR, "This class does not have a constructor"); + MAP.put(NOT_A_CLASS, "Not a class"); + MAP.put(ILLEGAL_ESCAPE_SEQUENCE, "Illegal escape sequence"); + + MAP.put(LOCAL_EXTENSION_PROPERTY, "Local extension properties are not allowed"); + MAP.put(LOCAL_VARIABLE_WITH_GETTER, "Local variables are not allowed to have getters"); + MAP.put(LOCAL_VARIABLE_WITH_SETTER, "Local variables are not allowed to have setters"); + MAP.put(VAL_WITH_SETTER, "A 'val'-property cannot have a setter"); + + MAP.put(NO_GET_METHOD, "No get method providing array access"); + MAP.put(NO_SET_METHOD, "No set method providing array access"); + + MAP.put(INC_DEC_SHOULD_NOT_RETURN_UNIT, "Functions inc(), dec() shouldn't return Unit to be used by operators ++, --"); + MAP.put(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT, "Function ''{0}'' should return Unit to be used by corresponding operator ''{1}''", + NAME, ELEMENT_TEXT); + MAP.put(ASSIGN_OPERATOR_AMBIGUITY, "Assignment operators ambiguity: {0}", AMBIGUOUS_CALLS); + + MAP.put(EQUALS_MISSING, "No method 'equals(jet.Any?) : jet.Boolean' available"); + MAP.put(ASSIGNMENT_IN_EXPRESSION_CONTEXT, "Assignments are not expressions, and only expressions are allowed in this context"); + MAP.put(NAMESPACE_IS_NOT_AN_EXPRESSION, "'namespace' is not an expression, it can only be used on the left-hand side of a dot ('.')"); + MAP.put(SUPER_IS_NOT_AN_EXPRESSION, "''{0}'' is not an expression, it can only be used on the left-hand side of a dot ('.')", TO_STRING); + MAP.put(DECLARATION_IN_ILLEGAL_CONTEXT, "Declarations are not allowed in this position"); + MAP.put(SETTER_PARAMETER_WITH_DEFAULT_VALUE, "Setter parameters cannot have default values"); + MAP.put(NO_THIS, "'this' is not defined in this context"); + MAP.put(SUPER_NOT_AVAILABLE, "No supertypes are accessible in this context"); + MAP.put(AMBIGUOUS_SUPER, "Many supertypes available, please specify the one you mean in angle brackets, e.g. 'super'"); + MAP.put(ABSTRACT_SUPER_CALL, "Abstract member cannot be accessed directly"); + MAP.put(NOT_A_SUPERTYPE, "Not a supertype"); + MAP.put(TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER, "Type arguments do not need to be specified in a 'super' qualifier"); + MAP.put(USELESS_CAST_STATIC_ASSERT_IS_FINE, "No cast needed, use ':' instead"); + MAP.put(USELESS_CAST, "No cast needed"); + MAP.put(CAST_NEVER_SUCCEEDS, "This cast can never succeed"); + MAP.put(WRONG_SETTER_PARAMETER_TYPE, "Setter parameter type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE); + MAP.put(WRONG_GETTER_RETURN_TYPE, "Getter return type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE); + MAP.put(NO_CLASS_OBJECT, "Please specify constructor invocation; classifier ''{0}'' does not have a class object", NAME); + MAP.put(NO_GENERICS_IN_SUPERTYPE_SPECIFIER, "Generic arguments of the base type must be specified"); + + MAP.put(HAS_NEXT_PROPERTY_AND_FUNCTION_AMBIGUITY, + "An ambiguity between 'iterator().hasNext()' function and 'iterator().hasNext' property"); + MAP.put(HAS_NEXT_MISSING, "Loop range must have an 'iterator().hasNext()' function or an 'iterator().hasNext' property"); + MAP.put(HAS_NEXT_FUNCTION_AMBIGUITY, "Function 'iterator().hasNext()' is ambiguous for this expression"); + MAP.put(HAS_NEXT_MUST_BE_READABLE, "The 'iterator().hasNext' property of the loop range must be readable"); + MAP.put(HAS_NEXT_PROPERTY_TYPE_MISMATCH, "The type of ''iterator().hasNext'' property of the loop range must be jet.Boolean, but is {0}", + RENDER_TYPE); + MAP.put(HAS_NEXT_FUNCTION_TYPE_MISMATCH, "The ''iterator().hasNext()'' function of the loop range must return jet.Boolean, but returns {0}", + RENDER_TYPE); + MAP.put(NEXT_AMBIGUITY, "Function 'iterator().next()' is ambiguous for this expression"); + MAP.put(NEXT_MISSING, "Loop range must have an 'iterator().next()' function"); + MAP.put(ITERATOR_MISSING, "For-loop range must have an iterator() method"); + MAP.put(ITERATOR_AMBIGUITY, "Method ''iterator()'' is ambiguous for this expression: {0}", AMBIGUOUS_CALLS); + + MAP.put(COMPARE_TO_TYPE_MISMATCH, "''compareTo()'' must return jet.Int, but returns {0}", RENDER_TYPE); + MAP.put(CALLEE_NOT_A_FUNCTION, "Expecting a function type, but found {0}", RENDER_TYPE); + + MAP.put(RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY, + "Returns are not allowed for functions with expression body. Use block body in '{...}'"); + MAP.put(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, "A 'return' expression required in a function with a block body ('{...}')"); + MAP.put(RETURN_TYPE_MISMATCH, "This function must return a value of type {0}", RENDER_TYPE); + MAP.put(EXPECTED_TYPE_MISMATCH, "Expected a value of type {0}", RENDER_TYPE); + MAP.put(ASSIGNMENT_TYPE_MISMATCH, + "Expected a value of type {0}. Assignment operation is not an expression, so it does not return any value", RENDER_TYPE); + MAP.put(IMPLICIT_CAST_TO_UNIT_OR_ANY, "Type was casted to ''{0}''. Please specify ''{0}'' as expected type, if you mean such cast", + RENDER_TYPE); + MAP.put(EXPRESSION_EXPECTED, "{0} is not an expression, and only expression are allowed here", new Renderer() { + @NotNull + @Override + public String render(@NotNull JetExpression expression) { + String expressionType = expression.toString(); + return expressionType.substring(0, 1) + + expressionType.substring(1).toLowerCase(); + } + }); + + MAP.put(UPPER_BOUND_VIOLATED, "Type argument is not within its bounds: should be subtype of ''{0}''", RENDER_TYPE, RENDER_TYPE); + MAP.put(FINAL_CLASS_OBJECT_UPPER_BOUND, "''{0}'' is a final type, and thus a class object cannot extend it", RENDER_TYPE); + MAP.put(FINAL_UPPER_BOUND, "''{0}'' is a final type, and thus a value of the type parameter is predetermined", RENDER_TYPE); + MAP.put(USELESS_ELVIS, "Elvis operator (?:) always returns the left operand of non-nullable type {0}", RENDER_TYPE); + MAP.put(CONFLICTING_UPPER_BOUNDS, "Upper bounds of {0} have empty intersection", NAME); + MAP.put(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS, "Class object upper bounds of {0} have empty intersection", NAME); + + MAP.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", DescriptorRenderer.TEXT); + MAP.put(ERROR_COMPILE_TIME_VALUE, "{0}", TO_STRING); + + MAP.put(ELSE_MISPLACED_IN_WHEN, "'else' entry must be the last one in a when-expression"); + + MAP.put(NO_ELSE_IN_WHEN, "'when' expression must contain 'else' branch"); + MAP.put(TYPE_MISMATCH_IN_RANGE, "Type mismatch: incompatible types of range and element checked in it"); + MAP.put(CYCLIC_INHERITANCE_HIERARCHY, "There's a cycle in the inheritance hierarchy for this type"); + + MAP.put(MANY_CLASSES_IN_SUPERTYPE_LIST, "Only one class may appear in a supertype list"); + MAP.put(SUPERTYPE_NOT_A_CLASS_OR_TRAIT, "Only classes and traits may serve as supertypes"); + MAP.put(SUPERTYPE_INITIALIZED_IN_TRAIT, "Traits cannot initialize supertypes"); + MAP.put(CONSTRUCTOR_IN_TRAIT, "A trait may not have a constructor"); + MAP.put(SECONDARY_CONSTRUCTORS_ARE_NOT_SUPPORTED, "Secondary constructors are not supported"); + MAP.put(SUPERTYPE_APPEARS_TWICE, "A supertype appears twice"); + MAP.put(FINAL_SUPERTYPE, "This type is final, so it cannot be inherited from"); + + MAP.put(ILLEGAL_SELECTOR, "Expression ''{0}'' cannot be a selector (occur after a dot)", TO_STRING); + + MAP.put(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION, "A type annotation is required on a value parameter"); + MAP.put(BREAK_OR_CONTINUE_OUTSIDE_A_LOOP, "'break' and 'continue' are only allowed inside a loop"); + MAP.put(NOT_A_LOOP_LABEL, "The label ''{0}'' does not denote a loop", TO_STRING); + MAP.put(NOT_A_RETURN_LABEL, "The label ''{0}'' does not reference to a context from which we can return", TO_STRING); + + MAP.put(ANONYMOUS_INITIALIZER_WITHOUT_CONSTRUCTOR, "Anonymous initializers are only allowed in the presence of a primary constructor"); + MAP.put(NULLABLE_SUPERTYPE, "A supertype cannot be nullable"); + MAP.put(UNSAFE_CALL, "Only safe calls (?.) are allowed on a nullable receiver of type {0}", RENDER_TYPE); + MAP.put(AMBIGUOUS_LABEL, "Ambiguous label"); + MAP.put(UNSUPPORTED, "Unsupported [{0}]", TO_STRING); + MAP.put(UNNECESSARY_SAFE_CALL, "Unnecessary safe call on a non-null receiver of type {0}", RENDER_TYPE); + MAP.put(UNNECESSARY_NOT_NULL_ASSERTION, "Unnecessary non-null assertion (!!) on a non-null receiver of type {0}", RENDER_TYPE); + MAP.put(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", new Renderer() { + @NotNull + @Override + public String render(@NotNull JetTypeConstraint typeConstraint) { + //noinspection ConstantConditions + return typeConstraint.getSubjectTypeParameterName().getReferencedName(); + } + }, NAME); + MAP.put(AUTOCAST_IMPOSSIBLE, "Automatic cast to ''{0}'' is impossible, because ''{1}'' could have changed since the is-check", RENDER_TYPE, + NAME); + + MAP.put(TYPE_MISMATCH_IN_FOR_LOOP, "The loop iterates over values of type {0} but the parameter is declared to be {1}", RENDER_TYPE, + RENDER_TYPE); + MAP.put(TYPE_MISMATCH_IN_CONDITION, "Condition must be of type jet.Boolean, but is of type {0}", RENDER_TYPE); + MAP.put(TYPE_MISMATCH_IN_TUPLE_PATTERN, "Type mismatch: subject is of type {0} but the pattern is a {1}-tuple", RENDER_TYPE, TO_STRING); + MAP.put(TYPE_MISMATCH_IN_BINDING_PATTERN, "{0} is not a supertype of {1}. Use ''is'' to match against {0}", RENDER_TYPE, RENDER_TYPE); + MAP.put(INCOMPATIBLE_TYPES, "Incompatible types: {0} and {1}", RENDER_TYPE, RENDER_TYPE); + MAP.put(EXPECTED_CONDITION, "Expected condition of jet.Boolean type"); + + MAP.put(CANNOT_CHECK_FOR_ERASED, "Cannot check for instance of erased type: {0}", RENDER_TYPE); + MAP.put(UNCHECKED_CAST, "Unchecked cast: {0} to {1}", RENDER_TYPE, RENDER_TYPE); + + MAP.put(INCONSISTENT_TYPE_PARAMETER_VALUES, "Type parameter {0} of ''{1}'' has inconsistent values: {2}", NAME, NAME, + new Renderer>() { + @NotNull + @Override + public String render(@NotNull Collection types) { + StringBuilder builder = new StringBuilder(); + for (Iterator iterator = types.iterator(); iterator.hasNext(); ) { + JetType jetType = iterator.next(); + builder.append(jetType); + if (iterator.hasNext()) { + builder.append(", "); + } + } + return builder.toString(); + } + }); + + MAP.put(EQUALITY_NOT_APPLICABLE, "Operator ''{0}'' cannot be applied to ''{1}'' and ''{2}''", new Renderer() { + @NotNull + @Override + public String render(@NotNull JetSimpleNameExpression nameExpression) { + //noinspection ConstantConditions + return nameExpression.getReferencedName(); + } + }, RENDER_TYPE, RENDER_TYPE); + + MAP.put(SENSELESS_COMPARISON, "Condition ''{0}'' is always ''{1}''", ELEMENT_TEXT, TO_STRING); + + MAP.put(OVERRIDING_FINAL_MEMBER, "''{0}'' in ''{1}'' is final and cannot be overridden", NAME, NAME); + MAP.put(CANNOT_WEAKEN_ACCESS_PRIVILEGE, "Cannot weaken access privilege ''{0}'' for ''{1}'' in ''{2}''", TO_STRING, NAME, NAME); + MAP.put(CANNOT_CHANGE_ACCESS_PRIVILEGE, "Cannot change access privilege ''{0}'' for ''{1}'' in ''{2}''", TO_STRING, NAME, NAME); + + MAP.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, "Return type of ''{0}'' is not a subtype of the return type of overridden member {1}", + NAME, DescriptorRenderer.TEXT); + + MAP.put(VAR_OVERRIDDEN_BY_VAL, "Var-property {0} cannot be overridden by val-property {1}", DescriptorRenderer.TEXT, + DescriptorRenderer.TEXT); + + MAP.put(ABSTRACT_MEMBER_NOT_IMPLEMENTED, "{0} must be declared abstract or implement abstract member {1}", RENDER_CLASS_OR_OBJECT, + DescriptorRenderer.TEXT); + + MAP.put(MANY_IMPL_MEMBER_NOT_IMPLEMENTED, "{0} must override {1} because it inherits many implementations of it", + RENDER_CLASS_OR_OBJECT, DescriptorRenderer.TEXT); + + MAP.put(CONFLICTING_OVERLOADS, "{1} is already defined in ''{0}''", DescriptorRenderer.TEXT, TO_STRING); + + + MAP.put(RESULT_TYPE_MISMATCH, "{0} must return {1} but returns {2}", TO_STRING, RENDER_TYPE, RENDER_TYPE); + MAP.put(UNSAFE_INFIX_CALL, + "Infix call corresponds to a dot-qualified call ''{0}.{1}({2})'' which is not allowed on a nullable receiver ''{0}''. " + + "Use '?.'-qualified call instead", + TO_STRING, TO_STRING, TO_STRING); + + MAP.put(OVERLOAD_RESOLUTION_AMBIGUITY, "Overload resolution ambiguity: {0}", AMBIGUOUS_CALLS); + MAP.put(NONE_APPLICABLE, "None of the following functions can be called with the arguments supplied: {0}", AMBIGUOUS_CALLS); + MAP.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter {0}", NAME); + MAP.put(MISSING_RECEIVER, "A receiver of type {0} is required", RENDER_TYPE); + MAP.put(NO_RECEIVER_ADMITTED, "No receiver can be passed to this function or property"); + + MAP.put(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, "Cannot create an instance of an abstract class"); + MAP.put(TYPE_INFERENCE_FAILED, "Type inference failed: {0}", TO_STRING); + MAP.put(WRONG_NUMBER_OF_TYPE_ARGUMENTS, "{0,choice,0#No type arguments|1#Type argument|1<{0,number,integer} type argument} expected", null); + + MAP.put(UNRESOLVED_IDE_TEMPLATE, "Unresolved IDE template: {0}", TO_STRING); + + MAP.put(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED, + "This expression is treated as an argument to the function call on the previous line. " + + "Separate it with a semicolon (;) if it is not intended to be an argument."); + + MAP.put(NOT_AN_ANNOTATION_CLASS, "''{0}'' is not an annotation class", TO_STRING); + + MAP.setImmutable(); + } + + private DefaultErrorMessages() { + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticFactoryToRendererMap.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticFactoryToRendererMap.java new file mode 100644 index 00000000000..cf5615bfa5b --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticFactoryToRendererMap.java @@ -0,0 +1,77 @@ +/* + * 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.lang.diagnostics.rendering; + +import com.intellij.psi.PsiElement; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.*; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author Evgeny Gerashchenko + * @since 4/13/12 + */ +public final class DiagnosticFactoryToRendererMap { + private final Map> map = + new HashMap>(); + private boolean immutable = false; + + private void checkMutability() { + if (immutable) { + throw new IllegalStateException("factory to renderer map is already immutable"); + } + } + + public void put(@NotNull SimpleDiagnosticFactory factory, @NotNull String message) { + checkMutability(); + map.put(factory, new SimpleDiagnosticRenderer(message)); + } + + public void put(@NotNull DiagnosticFactory1 factory, @NotNull String message, @Nullable Renderer rendererA) { + checkMutability(); + map.put(factory, new DiagnosticWithParameters1Renderer(message, rendererA)); + } + + public void put(@NotNull DiagnosticFactory2 factory, + @NotNull String message, + @Nullable Renderer rendererA, + @Nullable Renderer rendererB) { + checkMutability(); + map.put(factory, new DiagnosticWithParameters2Renderer(message, rendererA, rendererB)); + } + + public void put(@NotNull DiagnosticFactory3 factory, + @NotNull String message, + @Nullable Renderer rendererA, + @Nullable Renderer rendererB, + @Nullable Renderer rendererC) { + checkMutability(); + map.put(factory, new DiagnosticWithParameters3Renderer(message, rendererA, rendererB, rendererC)); + } + + @Nullable + public DiagnosticRenderer get(@NotNull AbstractDiagnosticFactory factory) { + return map.get(factory); + } + + public void setImmutable() { + immutable = false; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticRenderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticRenderer.java new file mode 100644 index 00000000000..324d8941830 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticRenderer.java @@ -0,0 +1,30 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; + +/** + * @author Evgeny Gerashchenko + * @since 4/12/12 + */ +public interface DiagnosticRenderer extends Renderer { + @NotNull + @Override + String render(@NotNull D diagnostic); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticRendererUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticRendererUtil.java new file mode 100644 index 00000000000..6fdd8653ee0 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticRendererUtil.java @@ -0,0 +1,34 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * @author Evgeny Gerashchenko + * @since 4/18/12 + */ +public class DiagnosticRendererUtil { + private DiagnosticRendererUtil() { + } + + @NotNull + public static

Object renderParameter(@NotNull P parameter, @Nullable Renderer

renderer) { + return renderer == null ? parameter : renderer.render(parameter); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters1Renderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters1Renderer.java new file mode 100644 index 00000000000..5727b40beda --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters1Renderer.java @@ -0,0 +1,45 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters1; + +import java.text.MessageFormat; + +import static org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticRendererUtil.renderParameter; + +/** +* @author Evgeny Gerashchenko +* @since 4/12/12 +*/ +public class DiagnosticWithParameters1Renderer implements DiagnosticRenderer> { + private final MessageFormat messageFormat; + private final Renderer rendererForA; + + public DiagnosticWithParameters1Renderer(@NotNull String message, @Nullable Renderer rendererForA) { + this.messageFormat = new MessageFormat(message); + this.rendererForA = rendererForA; + } + + @NotNull + @Override + public String render(@NotNull DiagnosticWithParameters1 diagnostic) { + return messageFormat.format(new Object[]{renderParameter(diagnostic.getA(), rendererForA)}); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters2Renderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters2Renderer.java new file mode 100644 index 00000000000..506f7cbe767 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters2Renderer.java @@ -0,0 +1,49 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters2; + +import java.text.MessageFormat; + +import static org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticRendererUtil.renderParameter; + +/** +* @author Evgeny Gerashchenko +* @since 4/12/12 +*/ +public class DiagnosticWithParameters2Renderer implements DiagnosticRenderer> { + private final MessageFormat messageFormat; + private final Renderer rendererForA; + private final Renderer rendererForB; + + public DiagnosticWithParameters2Renderer(@NotNull String message, @Nullable Renderer rendererForA, @Nullable Renderer rendererForB) { + this.messageFormat = new MessageFormat(message); + this.rendererForA = rendererForA; + this.rendererForB = rendererForB; + } + + @NotNull + @Override + public String render(@NotNull DiagnosticWithParameters2 diagnostic) { + return messageFormat.format(new Object[]{ + renderParameter(diagnostic.getA(), rendererForA), + renderParameter(diagnostic.getB(), rendererForB)}); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters3Renderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters3Renderer.java new file mode 100644 index 00000000000..e831df6b0e3 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DiagnosticWithParameters3Renderer.java @@ -0,0 +1,55 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters3; + +import java.text.MessageFormat; + +import static org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticRendererUtil.renderParameter; + +/** +* @author Evgeny Gerashchenko +* @since 4/12/12 +*/ +public class DiagnosticWithParameters3Renderer implements DiagnosticRenderer> { + private final MessageFormat messageFormat; + private final Renderer rendererForA; + private final Renderer rendererForB; + private final Renderer rendererForC; + + public DiagnosticWithParameters3Renderer(@NotNull String message, + @Nullable Renderer rendererForA, + @Nullable Renderer rendererForB, + @Nullable Renderer rendererForC) { + this.messageFormat = new MessageFormat(message); + this.rendererForA = rendererForA; + this.rendererForB = rendererForB; + this.rendererForC = rendererForC; + } + + @NotNull + @Override + public String render(@NotNull DiagnosticWithParameters3 diagnostic) { + return messageFormat.format(new Object[]{ + renderParameter(diagnostic.getA(), rendererForA), + renderParameter(diagnostic.getB(), rendererForB), + renderParameter(diagnostic.getC(), rendererForC)}); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DispatchingDiagnosticRenderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DispatchingDiagnosticRenderer.java new file mode 100644 index 00000000000..7a580b14556 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DispatchingDiagnosticRenderer.java @@ -0,0 +1,45 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; + +/** + * @author Evgeny Gerashchenko + * @since 4/13/12 + */ +public class DispatchingDiagnosticRenderer implements DiagnosticRenderer { + private final DiagnosticFactoryToRendererMap[] maps; + + public DispatchingDiagnosticRenderer(DiagnosticFactoryToRendererMap... maps) { + this.maps = maps; + } + + @NotNull + @Override + public String render(@NotNull Diagnostic diagnostic) { + for (DiagnosticFactoryToRendererMap map : maps) { + DiagnosticRenderer renderer = map.get(diagnostic.getFactory()); + if (renderer != null) { + //noinspection unchecked + return renderer.render(diagnostic); + } + } + throw new IllegalArgumentException("Don't know how to render diagnostic of type " + diagnostic.getFactory().getName()); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderer.java similarity index 77% rename from compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderer.java rename to compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderer.java index 3d427e03be6..a5bc6a660c8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderer.java @@ -14,17 +14,14 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.diagnostics; +package org.jetbrains.jet.lang.diagnostics.rendering; -import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; /** * @author abreslav */ -public interface Renderer

{ - +public interface Renderer { @NotNull - String render(@Nullable P element); + String render(@NotNull O object); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderers.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java similarity index 62% rename from compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderers.java rename to compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java index dcccc2d4f69..16527b27a30 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Renderers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java @@ -14,17 +14,20 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.diagnostics; +package org.jetbrains.jet.lang.diagnostics.rendering; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.Named; import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.resolve.DescriptorRenderer; +import java.util.Collection; + /** * @author svtk */ @@ -32,8 +35,8 @@ public class Renderers { public static final Renderer TO_STRING = new Renderer() { @NotNull @Override - public String render(@Nullable Object element) { - return element == null ? "null" : element.toString(); + public String render(@NotNull Object element) { + return element.toString(); } @Override @@ -45,8 +48,7 @@ public class Renderers { public static final Renderer NAME = new Renderer() { @NotNull @Override - public String render(@Nullable Object element) { - if (element == null) return "null"; + public String render(@NotNull Object element) { if (element instanceof Named) { return ((Named) element).getName(); } @@ -57,8 +59,7 @@ public class Renderers { public static final Renderer ELEMENT_TEXT = new Renderer() { @NotNull @Override - public String render(@Nullable PsiElement element) { - if (element == null) return "null"; + public String render(@NotNull PsiElement element) { return element.getText(); } }; @@ -66,8 +67,7 @@ public class Renderers { public static final Renderer RENDER_CLASS_OR_OBJECT = new Renderer() { @NotNull @Override - public String render(@Nullable JetClassOrObject classOrObject) { - assert classOrObject != null; + public String render(@NotNull JetClassOrObject classOrObject) { String name = classOrObject.getName() != null ? " '" + classOrObject.getName() + "'" : ""; if (classOrObject instanceof JetClass) { return "Class" + name; @@ -80,9 +80,24 @@ public class Renderers { public static final Renderer RENDER_TYPE = new Renderer() { @NotNull @Override - public String render(@Nullable JetType type) { - assert type != null; + public String render(@NotNull JetType type) { return DescriptorRenderer.TEXT.renderType(type); } }; + + public static final Renderer>> AMBIGUOUS_CALLS = + new Renderer>>() { + @NotNull + @Override + public String render(@NotNull Collection> argument) { + StringBuilder stringBuilder = new StringBuilder("\n"); + for (ResolvedCall call : argument) { + stringBuilder.append(DescriptorRenderer.TEXT.render(call.getResultingDescriptor())).append("\n"); + } + return stringBuilder.toString(); + } + }; + + private Renderers() { + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/SimpleDiagnosticRenderer.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/SimpleDiagnosticRenderer.java new file mode 100644 index 00000000000..0dd094f89f3 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/SimpleDiagnosticRenderer.java @@ -0,0 +1,38 @@ +/* + * 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.lang.diagnostics.rendering; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; + +/** +* @author Evgeny Gerashchenko +* @since 4/12/12 +*/ +public class SimpleDiagnosticRenderer implements DiagnosticRenderer { + private final String message; + + public SimpleDiagnosticRenderer(@NotNull String message) { + this.message = message; + } + + @NotNull + @Override + public String render(@NotNull Diagnostic diagnostic) { + return message; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java index b8570e16d4b..9d0da50c551 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java @@ -286,7 +286,7 @@ public class JetParsing extends AbstractJetParsing { } if (declType == null) { - errorAndAdvance("Expecting namespace or top level declaration"); + errorAndAdvance("Expecting package directive or top level declaration"); decl.drop(); } else { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index 8d4a4b70de8..c3108cb8bcc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -181,7 +181,7 @@ public class DeclarationsChecker { if (!(classDescriptor.getModality() == Modality.ABSTRACT) && classDescriptor.getKind() != ClassKind.ENUM_CLASS) { JetClass classElement = (JetClass) BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor); String name = property.getName(); - trace.report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor, classElement)); + trace.report(ABSTRACT_PROPERTY_IN_NON_ABSTRACT_CLASS.on(property, name != null ? name : "", classDescriptor)); return; } if (classDescriptor.getKind() == ClassKind.TRAIT) { @@ -252,7 +252,7 @@ public class DeclarationsChecker { boolean inAbstractClass = classDescriptor.getModality() == Modality.ABSTRACT; if (hasAbstractModifier && !inAbstractClass && !inTrait && !inEnum) { JetClass classElement = (JetClass) BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor); - trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName(), classDescriptor, classElement)); + trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.getName(), classDescriptor)); } if (hasAbstractModifier && inTrait) { trace.report(ABSTRACT_MODIFIER_IN_TRAIT.on(function)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java index f971dcdb619..f7159a905cc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java @@ -36,7 +36,7 @@ public class DelegatingBindingTrace implements BindingTrace { private final BindingContext bindingContext = new BindingContext() { @Override public Collection getDiagnostics() { - throw new UnsupportedOperationException(); // TODO + return diagnostics; } @Override @@ -57,6 +57,7 @@ public class DelegatingBindingTrace implements BindingTrace { } @Override + @NotNull public BindingContext getBindingContext() { return bindingContext; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index e40d2cdbcec..5fae6c49bcf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -264,7 +264,7 @@ public class DescriptorResolver { type = typeResolver.resolveType(parameterScope, typeReference, trace, true); } - ValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(functionDescriptor, valueParameter, i, type, trace); + ValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(parameterScope, functionDescriptor, valueParameter, i, type, trace); parameterScope.addVariableDescriptor(valueParameterDescriptor); result.add(valueParameterDescriptor); } @@ -272,7 +272,7 @@ public class DescriptorResolver { } @NotNull - public MutableValueParameterDescriptor resolveValueParameterDescriptor(DeclarationDescriptor declarationDescriptor, JetParameter valueParameter, int index, JetType type, BindingTrace trace) { + public MutableValueParameterDescriptor resolveValueParameterDescriptor(JetScope scope, DeclarationDescriptor declarationDescriptor, JetParameter valueParameter, int index, JetType type, BindingTrace trace) { JetType varargElementType = null; JetType variableType = type; if (valueParameter.hasModifier(JetTokens.VARARG_KEYWORD)) { @@ -282,7 +282,7 @@ public class DescriptorResolver { MutableValueParameterDescriptor valueParameterDescriptor = new ValueParameterDescriptorImpl( declarationDescriptor, index, - annotationResolver.createAnnotationStubs(valueParameter.getModifierList(), trace), + annotationResolver.resolveAnnotations(scope, valueParameter.getModifierList(), trace), JetPsiUtil.safeName(valueParameter.getName()), valueParameter.isMutable(), variableType, @@ -431,6 +431,9 @@ public class DescriptorResolver { // Error is reported by the parser type = ErrorUtils.createErrorType("Annotation is absent"); } + if (parameter.hasModifier(JetTokens.VARARG_KEYWORD)) { + return getVarargParameterType(type); + } return type; } @@ -724,7 +727,7 @@ public class DescriptorResolver { JetType inType = propertyDescriptor.getType(); if (inType != null) { if (!TypeUtils.equalTypes(type, inType)) { - trace.report(WRONG_SETTER_PARAMETER_TYPE.on(typeReference, inType)); + trace.report(WRONG_SETTER_PARAMETER_TYPE.on(typeReference, inType, type)); } } else { @@ -732,7 +735,7 @@ public class DescriptorResolver { } } - MutableValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(setterDescriptor, parameter, 0, type, trace); + MutableValueParameterDescriptor valueParameterDescriptor = resolveValueParameterDescriptor(scope, setterDescriptor, parameter, 0, type, trace); setterDescriptor.initialize(valueParameterDescriptor); } else { @@ -777,7 +780,7 @@ public class DescriptorResolver { if (returnTypeReference != null) { returnType = typeResolver.resolveType(scope, returnTypeReference, trace, true); if (outType != null && !TypeUtils.equalTypes(returnType, outType)) { - trace.report(WRONG_GETTER_RETURN_TYPE.on(returnTypeReference, propertyDescriptor.getReturnType())); + trace.report(WRONG_GETTER_RETURN_TYPE.on(returnTypeReference, propertyDescriptor.getReturnType(), outType)); } } @@ -920,7 +923,7 @@ public class DescriptorResolver { for (JetType bound : typeParameterDescriptor.getUpperBounds()) { JetType substitutedBound = substitutor.safeSubstitute(bound, Variance.INVARIANT); if (!JetTypeChecker.INSTANCE.isSubtypeOf(typeArgument, substitutedBound)) { - trace.report(UPPER_BOUND_VIOLATED.on(argumentTypeReference, substitutedBound)); + trace.report(UPPER_BOUND_VIOLATED.on(argumentTypeReference, substitutedBound, typeArgument)); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java index e88d16dd086..6fd1de795c0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java @@ -33,9 +33,7 @@ import java.util.Set; import static org.jetbrains.jet.lang.diagnostics.Errors.*; import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; -import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMapper.Status.ERROR; -import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMapper.Status.OK; -import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMapper.Status.WEAK_ERROR; +import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMapper.Status.*; /** * @author abreslav @@ -219,10 +217,6 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap status = ERROR; } - if (candidateCall.getThisObject().exists() != candidateCall.getResultingDescriptor().getExpectedThisObject().exists()) { - assert false : "Shouldn't happen because of TaskPrioritizer: " + candidateCall.getCandidateDescriptor(); - } - return status; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java index 0421553c7a1..f96d11a93ed 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java @@ -529,6 +529,23 @@ public class TypeUtils { return null; } + private static void addAllClassDescriptors(@NotNull JetType type, @NotNull Set set) { + ClassDescriptor cd = getClassDescriptor(type); + if (cd != null) { + set.add(cd); + } + for (TypeProjection projection : type.getArguments()) { + addAllClassDescriptors(projection.getType(), set); + } + } + + @NotNull + public static List getAllClassDescriptors(@NotNull JetType type) { + Set classDescriptors = new HashSet(); + addAllClassDescriptors(type, classDescriptors); + return new ArrayList(classDescriptors); + } + public static boolean hasUnsubstitutedTypeParameters(JetType type) { if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) { return true; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 8ea9a700549..c0a400931f8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -195,7 +195,8 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { type = ErrorUtils.createErrorType("Cannot be inferred"); } } - ValueParameterDescriptor valueParameterDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type, context.trace); + ValueParameterDescriptor valueParameterDescriptor = context.expressionTypingServices.getDescriptorResolver().resolveValueParameterDescriptor( + context.scope, functionDescriptor, declaredParameter, i, type, context.trace); valueParameterDescriptors.add(valueParameterDescriptor); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java index ab314670626..98283823254 100644 --- a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java +++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java @@ -19,8 +19,10 @@ package org.jetbrains.jet.resolve; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.diagnostics.Renderer; +import org.jetbrains.jet.lang.diagnostics.rendering.Renderer; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeProjection; @@ -28,10 +30,7 @@ import org.jetbrains.jet.lang.types.Variance; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lexer.JetTokens; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.List; +import java.util.*; /** * @author abreslav @@ -79,7 +78,7 @@ public class DescriptorRenderer implements Renderer { @Override public Void visitValueParameterDescriptor(ValueParameterDescriptor descriptor, StringBuilder builder) { - super.visitVariableDescriptor(descriptor, builder); + super.visitVariableDescriptor(descriptor, builder, true); if (descriptor.hasDefaultValue()) { builder.append(" = ..."); } @@ -120,6 +119,15 @@ public class DescriptorRenderer implements Renderer { } } + private static List getOuterClassesNames(ClassDescriptor cd) { + ArrayList result = new ArrayList(); + while (cd.getContainingDeclaration() instanceof ClassifierDescriptor) { + result.add(cd.getName()); + cd = (ClassDescriptor)cd.getContainingDeclaration(); + } + return result; + } + private String renderDefaultType(JetType type, boolean shortNamesOnly) { StringBuilder sb = new StringBuilder(); ClassifierDescriptor cd = type.getConstructor().getDeclarationDescriptor(); @@ -130,7 +138,18 @@ public class DescriptorRenderer implements Renderer { typeNameObject = type.getConstructor(); } else { - typeNameObject = shortNamesOnly ? cd.getName() : DescriptorUtils.getFQName(cd); + if (shortNamesOnly) { + // for nested classes qualified name should be used + typeNameObject = cd.getName(); + DeclarationDescriptor parent = cd.getContainingDeclaration(); + while (parent instanceof ClassDescriptor) { + typeNameObject = parent.getName() + "." + typeNameObject; + parent = parent.getContainingDeclaration(); + } + } + else { + typeNameObject = DescriptorUtils.getFQName(cd); + } } sb.append(typeNameObject); @@ -209,8 +228,7 @@ public class DescriptorRenderer implements Renderer { @NotNull @Override - public String render(DeclarationDescriptor declarationDescriptor) { - if (declarationDescriptor == null) return lt() + "null>"; + public String render(@NotNull DeclarationDescriptor declarationDescriptor) { StringBuilder stringBuilder = new StringBuilder(); declarationDescriptor.accept(rootVisitor, stringBuilder); if (shouldRenderDefinedIn()) { @@ -228,7 +246,8 @@ public class DescriptorRenderer implements Renderer { final DeclarationDescriptor containingDeclaration = declarationDescriptor.getContainingDeclaration(); if (containingDeclaration != null) { - renderFullyQualifiedName(containingDeclaration, stringBuilder); + FqNameUnsafe fqName = DescriptorUtils.getFQName(containingDeclaration); + stringBuilder.append(FqName.ROOT.toUnsafe().equals(fqName) ? "root package" : escape(fqName.getFqName())); } } @@ -245,34 +264,34 @@ public class DescriptorRenderer implements Renderer { return s; } - private void renderFullyQualifiedName(DeclarationDescriptor descriptor, StringBuilder stringBuilder) { - DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration != null) { - renderFullyQualifiedName(containingDeclaration, stringBuilder); - stringBuilder.append("."); - } - stringBuilder.append(escape(descriptor.getName())); - } - private class RenderDeclarationDescriptorVisitor extends DeclarationDescriptorVisitor { @Override public Void visitValueParameterDescriptor(ValueParameterDescriptor descriptor, StringBuilder builder) { builder.append(renderKeyword("value-parameter")).append(" "); - if (descriptor.getVarargElementType() != null) { - builder.append(renderKeyword("vararg")).append(" "); - } return super.visitValueParameterDescriptor(descriptor, builder); } @Override public Void visitVariableDescriptor(VariableDescriptor descriptor, StringBuilder builder) { + return visitVariableDescriptor(descriptor, builder, false); + } + + protected Void visitVariableDescriptor(VariableDescriptor descriptor, StringBuilder builder, boolean skipValVar) { + JetType type = descriptor.getType(); + if (descriptor instanceof ValueParameterDescriptor) { + JetType varargElementType = ((ValueParameterDescriptor)descriptor).getVarargElementType(); + if (varargElementType != null) { + builder.append(renderKeyword("vararg")).append(" "); + type = varargElementType; + } + } String typeString = renderPropertyPrefixAndComputeTypeString( builder, - descriptor.isVar(), + skipValVar ? null : descriptor.isVar(), Collections.emptyList(), ReceiverDescriptor.NO_RECEIVER, - descriptor.getType()); + type); renderName(descriptor, builder); builder.append(" : ").append(escape(typeString)); return super.visitVariableDescriptor(descriptor, builder); @@ -280,13 +299,15 @@ public class DescriptorRenderer implements Renderer { private String renderPropertyPrefixAndComputeTypeString( @NotNull StringBuilder builder, - boolean isVar, + @Nullable Boolean isVar, @NotNull List typeParameters, @NotNull ReceiverDescriptor receiver, @Nullable JetType outType) { String typeString = lt() + "no type>"; if (outType != null) { - builder.append(renderKeyword(isVar ? "var" : "val")).append(" "); + if (isVar != null) { + builder.append(renderKeyword(isVar ? "var" : "val")).append(" "); + } typeString = renderType(outType); } @@ -315,22 +336,27 @@ public class DescriptorRenderer implements Renderer { } private void renderVisibility(Visibility visibility, StringBuilder builder) { - builder.append(visibility).append(" "); + if ("package".equals(visibility.toString())) { + builder.append("public/*package*/ "); + } else { + builder.append(renderKeyword(visibility.toString())).append(" "); + } } private void renderModality(Modality modality, StringBuilder builder) { + String keyword = ""; switch (modality) { case FINAL: - builder.append("final"); + keyword = "final"; break; case OPEN: - builder.append("open"); + keyword = "open"; break; case ABSTRACT: - builder.append("abstract"); + keyword = "abstract"; break; } - builder.append(" "); + builder.append(renderKeyword(keyword)).append(" "); } @Override @@ -388,6 +414,7 @@ public class DescriptorRenderer implements Renderer { } } builder.append(">"); + return true; } return false; } @@ -475,7 +502,13 @@ public class DescriptorRenderer implements Renderer { } protected void renderTypeParameter(TypeParameterDescriptor descriptor, StringBuilder builder) { - if (!descriptor.isReified()) { + if (descriptor.isReified()) { + String variance = descriptor.getVariance().toString(); + if (!variance.isEmpty()) { + builder.append(renderKeyword(variance)).append(" "); + } + } + else { builder.append(renderKeyword("erased")).append(" "); } renderName(descriptor, builder); diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java index b1085c67c9d..e2b4b232146 100644 --- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java +++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java @@ -32,11 +32,12 @@ public class Slices { @Override public boolean processRewrite(WritableSlice slice, K key, V oldValue, V newValue) { - assert (oldValue == null && newValue == null) || (oldValue != null && oldValue.equals(newValue)) - : "Rewrite at slice " + slice + - " key: " + key + - " old value: " + oldValue + '@' + System.identityHashCode(oldValue) + - " new value: " + newValue + '@' + System.identityHashCode(newValue); + if (!((oldValue == null && newValue == null) || (oldValue != null && oldValue.equals(newValue)))) { + throw new IllegalStateException("Rewrite at slice " + slice + + " key: " + key + + " old value: " + oldValue + '@' + System.identityHashCode(oldValue) + + " new value: " + newValue + '@' + System.identityHashCode(newValue)); + } return true; } }; diff --git a/compiler/integration-tests/compiler-integration-tests.iml b/compiler/integration-tests/compiler-integration-tests.iml new file mode 100644 index 00000000000..b9f5f634fdc --- /dev/null +++ b/compiler/integration-tests/compiler-integration-tests.iml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/compiler/integration-tests/data/hello.compile.gold b/compiler/integration-tests/data/hello.compile.gold new file mode 100644 index 00000000000..a14ac74940f --- /dev/null +++ b/compiler/integration-tests/data/hello.compile.gold @@ -0,0 +1 @@ +Return code: 0 diff --git a/compiler/integration-tests/data/hello.kt b/compiler/integration-tests/data/hello.kt new file mode 100644 index 00000000000..4c4a4b67c8c --- /dev/null +++ b/compiler/integration-tests/data/hello.kt @@ -0,0 +1,5 @@ +package Hello + +fun main(args : Array) { + System.out?.println("Hello!") +} diff --git a/compiler/integration-tests/data/hello.run.gold b/compiler/integration-tests/data/hello.run.gold new file mode 100644 index 00000000000..fc47ec99014 --- /dev/null +++ b/compiler/integration-tests/data/hello.run.gold @@ -0,0 +1,2 @@ +OUT Hello! +Return code: 0 diff --git a/compiler/integration-tests/data/help.gold b/compiler/integration-tests/data/help.gold new file mode 100644 index 00000000000..873ad73b72c --- /dev/null +++ b/compiler/integration-tests/data/help.gold @@ -0,0 +1,16 @@ +OUT Usage: org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments +OUT -output [String] output directory +OUT -jar [String] jar file name +OUT -src [String] source file or directory +OUT -module [String] module to compile +OUT -classpath [String] classpath to use when compiling +OUT -includeRuntime [flag] +OUT -stdlib [String] Path to the stdlib.jar +OUT -jdkHeaders [String] Path to the kotlin-jdk-headers.jar +OUT -help (-h) [flag] +OUT -mode [String] Special compiler modes: stubs or jdkHeaders +OUT -tags [flag] +OUT -verbose [flag] +OUT -version [flag] +ERR exec() finished with INTERNAL_ERROR return code +Return code: 2 diff --git a/compiler/integration-tests/src/org/jetbrains/kotlin/CompilerSmokeTest.java b/compiler/integration-tests/src/org/jetbrains/kotlin/CompilerSmokeTest.java new file mode 100644 index 00000000000..72d912e47a7 --- /dev/null +++ b/compiler/integration-tests/src/org/jetbrains/kotlin/CompilerSmokeTest.java @@ -0,0 +1,38 @@ +/* + * 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.kotlin; + +import org.junit.Test; + +import java.io.File; + +import static junit.framework.Assert.*; + +public class CompilerSmokeTest extends KotlinIntegrationTestBase { + @Test + public void help() throws Exception { + runCompiler("help", "--help"); + } + + @Test + public void compileAndRunHelloApp() throws Exception { + final String jar = tempDir.getAbsolutePath() + File.separator + "hello.jar"; + + assertEquals("compilation failed", 0, runCompiler("hello.compile", "-src", "hello.kt", "-jar", jar)); + runJava("hello.run", "-cp", jar, "Hello.namespace"); + } +} diff --git a/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java b/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java new file mode 100644 index 00000000000..8f5ab4b894a --- /dev/null +++ b/compiler/integration-tests/src/org/jetbrains/kotlin/KotlinIntegrationTestBase.java @@ -0,0 +1,192 @@ +/* + * 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.kotlin; + +import com.google.common.base.Charsets; +import com.google.common.io.Files; +import com.intellij.execution.ExecutionException; +import com.intellij.execution.configurations.GeneralCommandLine; +import com.intellij.execution.process.OSProcessHandler; +import com.intellij.execution.process.ProcessAdapter; +import com.intellij.execution.process.ProcessEvent; +import com.intellij.execution.process.ProcessOutputTypes; +import com.intellij.openapi.application.PathManager; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.SystemInfo; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.util.ArrayUtil; +import com.intellij.util.Function; +import org.junit.Rule; +import org.junit.rules.TestRule; +import org.junit.rules.TestWatcher; +import org.junit.runner.Description; +import sun.misc.JarFilter; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; + +import static com.google.common.base.Charsets.UTF_8; +import static org.junit.Assert.*; + +public abstract class KotlinIntegrationTestBase { + protected File tempDir; + + @Rule + public TestRule watchman = new TestWatcher() { + @Override + protected void starting(Description description) { + tempDir = Files.createTempDir(); + } + + @Override + protected void succeeded(Description description) { + try { + tempDir.delete(); + } catch (Exception e) { + System.out.print("Can't delete temp directory " + tempDir + ": " + e); + } + } + + @Override + protected void failed(Throwable e, Description description) { + System.err.println("Temp directory: " + tempDir); + } + }; + + protected int runCompiler(String logName, String... arguments) throws Exception { + final File lib = getCompilerLib(); + + final File[] jars = lib.listFiles(new JarFilter()); + final String classpath = StringUtil.join(jars, new Function() { + @Override + public String fun(File file) { + return file.getAbsolutePath(); + } + }, File.pathSeparator); + + Collection javaArgs = new ArrayList(); + javaArgs.add("-cp"); + javaArgs.add(classpath); + javaArgs.add("org.jetbrains.jet.cli.jvm.K2JVMCompiler"); + Collections.addAll(javaArgs, arguments); + + return runJava(logName, ArrayUtil.toStringArray(javaArgs)); + } + + protected int runJava(String logName, String... arguments) throws Exception { + GeneralCommandLine commandLine = new GeneralCommandLine(); + commandLine.setWorkDirectory(getTestDataDirectory()); + commandLine.setExePath(getJavaRuntime().getAbsolutePath()); + commandLine.addParameters(arguments); + + StringBuilder executionLog = new StringBuilder(); + int exitCode = runProcess(commandLine, executionLog); + + if (logName == null) { + assertEquals("Non-zero exit code", 0, exitCode); + } + else { + check(logName, executionLog); + } + + return exitCode; + } + + protected void check(String baseName, StringBuilder content) throws IOException { + final File tmpFile = new File(getTestDataDirectory(), baseName + ".tmp"); + final File goldFile = new File(getTestDataDirectory(), baseName + ".gold"); + + if (!goldFile.isFile()) { + Files.write(content, tmpFile, Charsets.UTF_8); + fail("No gold file " + goldFile); + } + else { + final String goldContent = Files.toString(goldFile, UTF_8); + if (!goldContent.equals(content.toString())) { + Files.write(content, tmpFile, Charsets.UTF_8); + fail("tmp and gold differ, tmp file: " + tmpFile); + } + tmpFile.delete(); + } + } + + protected int runProcess(final GeneralCommandLine commandLine, final StringBuilder executionLog) throws ExecutionException { + OSProcessHandler handler = + new OSProcessHandler(commandLine.createProcess(), commandLine.getCommandLineString(), commandLine.getCharset()); + + final StringBuilder outContent = new StringBuilder(); + final StringBuilder errContent = new StringBuilder(); + + handler.addProcessListener(new ProcessAdapter() { + @Override + public void onTextAvailable(ProcessEvent event, Key outputType) { + if (outputType == ProcessOutputTypes.SYSTEM) { + System.out.print(event.getText()); + } + else if (outputType == ProcessOutputTypes.STDOUT) { + appendToContent(outContent, "OUT ", event.getText()); + } + else if (outputType == ProcessOutputTypes.STDERR) { + appendToContent(errContent, "ERR ", event.getText()); + } + } + + private void appendToContent(StringBuilder content, String prefix, String line) { + content.append(prefix); + content.append(StringUtil.trimTrailing(line)); + content.append("\n"); + } + }); + + handler.startNotify(); + handler.waitFor(); + int exitCode = handler.getProcess().exitValue(); + + executionLog.append(outContent); + executionLog.append(errContent); + executionLog.append("Return code: ").append(exitCode).append("\n"); + + return exitCode; + } + + protected static File getJavaRuntime() { + final File javaHome = new File(System.getProperty("java.home")); + final String javaExe = SystemInfo.isWindows ? "java.exe" : "java"; + + final File runtime = new File(javaHome, "bin" + File.separator + javaExe); + assertTrue("no java runtime at " + runtime, runtime.isFile()); + + return runtime; + } + + protected static File getCompilerLib() { + final File file = new File(getKotlinProjectHome(), "dist" + File.separator + "kotlinc" + File.separator + "lib"); + assertTrue("no kotlin compiler lib at " + file, file.isDirectory()); + return file; + } + + protected static File getTestDataDirectory() { + return new File(getKotlinProjectHome(), "compiler" + File.separator + "integration-tests" + File.separator + "data"); + } + + protected static File getKotlinProjectHome() { + return new File(PathManager.getHomePath()).getParentFile(); + } +} diff --git a/compiler/testData/diagnostics/tests/NamedArgumentsAndDefaultValues.jet b/compiler/testData/diagnostics/tests/NamedArgumentsAndDefaultValues.jet index 8cfd720f404..161e6f7f743 100644 --- a/compiler/testData/diagnostics/tests/NamedArgumentsAndDefaultValues.jet +++ b/compiler/testData/diagnostics/tests/NamedArgumentsAndDefaultValues.jet @@ -19,5 +19,5 @@ fun test() { bar(1, 1, "") bar(1, 1, "") bar(1, z = "") - bar(1, zz = "", zz.foo) + bar(1, zz = "", zz.foo) } diff --git a/compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.jet b/compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.jet index e8b80c8f4ca..3248de9941e 100644 --- a/compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.jet +++ b/compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.jet @@ -1,4 +1,4 @@ fun test() { fun foo(){} - foo<in Int>() + foo<in Int>() } diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-negative.jet b/compiler/testData/diagnostics/tests/annotations/kt1860-negative.jet new file mode 100644 index 00000000000..620011f493a --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/kt1860-negative.jet @@ -0,0 +1,9 @@ +fun foo(varargs f : Int) {} + +var bar : Int = 1 + set(varargs v) {} + +val x : (Int) -> Int = {([varargs] x : Int) -> x} + +class Hello(varargs args: Any) { +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.jet b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.jet new file mode 100644 index 00000000000..bf00815f64a --- /dev/null +++ b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.jet @@ -0,0 +1,11 @@ +annotation class test {} + +fun foo(test f : Int) {} + +var bar : Int = 1 + set(test v) {} + +val x : (Int) -> Int = {([test] x : Int) -> x} + +class Hello(test args: Any) { +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/varargs/kt1838-param.jet b/compiler/testData/diagnostics/tests/varargs/kt1838-param.jet new file mode 100644 index 00000000000..607bbfd1ebb --- /dev/null +++ b/compiler/testData/diagnostics/tests/varargs/kt1838-param.jet @@ -0,0 +1,5 @@ +class A(vararg t : Int) { + { + val t1 : IntArray = t + } +} diff --git a/compiler/testData/diagnostics/tests/varargs/kt1838-val.jet b/compiler/testData/diagnostics/tests/varargs/kt1838-val.jet new file mode 100644 index 00000000000..ae719ee3d42 --- /dev/null +++ b/compiler/testData/diagnostics/tests/varargs/kt1838-val.jet @@ -0,0 +1,5 @@ +class A(vararg val t : Int) { + { + val t1 : IntArray = t + } +} diff --git a/compiler/testData/javaDescriptorResolver/inner.java b/compiler/testData/javaDescriptorResolver/inner.java new file mode 100644 index 00000000000..cde64b5217a --- /dev/null +++ b/compiler/testData/javaDescriptorResolver/inner.java @@ -0,0 +1,10 @@ + +class A implements B.C { +} + +class B { + B(C c) {} + + interface C { + } +} diff --git a/compiler/testData/psi/FileStart_ERR.txt b/compiler/testData/psi/FileStart_ERR.txt index 5730db1fdf6..fe469cd014b 100644 --- a/compiler/testData/psi/FileStart_ERR.txt +++ b/compiler/testData/psi/FileStart_ERR.txt @@ -1,9 +1,9 @@ JetFile: FileStart_ERR.jet NAMESPACE_HEADER - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(DIV)('/') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(package)('package') PsiWhiteSpace(' ') MODIFIER_LIST @@ -31,5 +31,5 @@ JetFile: FileStart_ERR.jet USER_TYPE REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('foo') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration \ No newline at end of file diff --git a/compiler/testData/psi/Imports_ERR.txt b/compiler/testData/psi/Imports_ERR.txt index 6f880181140..9406df03bb6 100644 --- a/compiler/testData/psi/Imports_ERR.txt +++ b/compiler/testData/psi/Imports_ERR.txt @@ -31,7 +31,7 @@ JetFile: Imports_ERR.jet REFERENCE_EXPRESSION PsiErrorElement:Expecting qualified name - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(MUL)('*') PsiWhiteSpace('\n') IMPORT_DIRECTIVE @@ -125,7 +125,7 @@ JetFile: Imports_ERR.jet PsiErrorElement:Expecting type name PsiElement(MUL)('*') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(as)('as') PsiWhiteSpace(' ') MODIFIER_LIST @@ -158,7 +158,7 @@ JetFile: Imports_ERR.jet PsiErrorElement:Expecting type name PsiElement(MUL)('*') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(as)('as') PsiWhiteSpace('\n\n') IMPORT_DIRECTIVE diff --git a/compiler/testData/psi/NamespaceBlockFirst.txt b/compiler/testData/psi/NamespaceBlockFirst.txt index c60803e634b..ee2e8d110aa 100644 --- a/compiler/testData/psi/NamespaceBlockFirst.txt +++ b/compiler/testData/psi/NamespaceBlockFirst.txt @@ -1,7 +1,7 @@ JetFile: NamespaceBlockFirst.jet NAMESPACE_HEADER - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(package)('package') PsiWhiteSpace(' ') MODIFIER_LIST @@ -12,7 +12,7 @@ JetFile: NamespaceBlockFirst.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('foobar') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(LBRACE)('{') PsiWhiteSpace('\n ') PROPERTY @@ -39,5 +39,5 @@ JetFile: NamespaceBlockFirst.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiWhiteSpace('\n') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/Properties_ERR.txt b/compiler/testData/psi/Properties_ERR.txt index ac727cd3088..f15af5049e5 100644 --- a/compiler/testData/psi/Properties_ERR.txt +++ b/compiler/testData/psi/Properties_ERR.txt @@ -119,22 +119,22 @@ JetFile: Properties_ERR.jet MODIFIER_LIST PsiElement(public)('public') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(LPAR)('(') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(RPAR)(')') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(LBRACE)('{') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(RBRACE)('}') PsiWhiteSpace('\n ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(LPAR)('(') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(RPAR)(')') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(EQ)('=') PsiWhiteSpace(' ') PROPERTY diff --git a/compiler/testData/psi/RootNamespace.txt b/compiler/testData/psi/RootNamespace.txt index 70d461713cc..71de1d19f32 100644 --- a/compiler/testData/psi/RootNamespace.txt +++ b/compiler/testData/psi/RootNamespace.txt @@ -16,7 +16,7 @@ JetFile: RootNamespace.jet PsiWhiteSpace('\n\n') TYPE_PARAMETER_LIST - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(package)('package') PsiWhiteSpace(' ') MODIFIER_LIST @@ -31,7 +31,7 @@ JetFile: RootNamespace.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('bar') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(LBRACE)('{') PsiWhiteSpace('\n ') FUN @@ -130,5 +130,5 @@ JetFile: RootNamespace.jet PsiWhiteSpace('\n ') PsiElement(RBRACE)('}') PsiWhiteSpace('\n') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/greatSyntacticShift/functionTypes.txt b/compiler/testData/psi/greatSyntacticShift/functionTypes.txt index fd200c73574..d1da2d361c7 100644 --- a/compiler/testData/psi/greatSyntacticShift/functionTypes.txt +++ b/compiler/testData/psi/greatSyntacticShift/functionTypes.txt @@ -13,7 +13,7 @@ JetFile: functionTypes.jet PsiWhiteSpace('\n') PsiElement(RBRACE)('}') PsiWhiteSpace('\n\n') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(package)('package') PsiWhiteSpace(' ') MODIFIER_LIST @@ -24,7 +24,7 @@ JetFile: functionTypes.jet REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('n') PsiWhiteSpace(' ') - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(LBRACE)('{') PsiWhiteSpace('\n ') CLASS @@ -34,7 +34,7 @@ JetFile: functionTypes.jet PsiWhiteSpace('\n') TYPE_PARAMETER_LIST - PsiErrorElement:Expecting namespace or top level declaration + PsiErrorElement:Expecting package directive or top level declaration PsiElement(RBRACE)('}') PsiWhiteSpace('\n') CLASS diff --git a/compiler/testData/renderer/Classes.kt b/compiler/testData/renderer/Classes.kt index ecdd7945e3c..e69596a832a 100644 --- a/compiler/testData/renderer/Classes.kt +++ b/compiler/testData/renderer/Classes.kt @@ -29,21 +29,21 @@ private enum class TheEnum(val rgb : Int) { VAL1 : TheEnum(0xFF0000) } -//package rendererTest defined in . -//internal final annotation class TheAnnotation defined in ..rendererTest -//public open class TheClass defined in ..rendererTest -// defined in ..rendererTest.TheClass -// defined in ..rendererTest.TheClass -//private final val privateVal : jet.Int defined in ..rendererTest.TheClass -//internal final val shouldBeFinal : jet.Int defined in ..rendererTest.TheClass -//protected abstract fun foo() : Unit defined in ..rendererTest.TheClass -//private final class Inner defined in ..rendererTest.TheClass -//internal final class InternalClass defined in ..rendererTest -//internal trait TheTrait defined in ..rendererTest -//internal abstract fun abstractFun() : Unit defined in ..rendererTest.TheTrait -//object : rendererTest.TheClass defined in ..rendererTest.TheTrait -//internal final fun classObjectFunction() : jet.Int defined in ..rendererTest.TheTrait. -//private final enum class TheEnum defined in ..rendererTest -//value-parameter val rgb : jet.Int defined in ..rendererTest.TheEnum. -//internal final class VAL1 : rendererTest.TheEnum defined in ..rendererTest.TheEnum.class-object-for-TheEnum -//internal final val VAL1 : rendererTest.TheEnum.class-object-for-TheEnum.VAL1 defined in ..rendererTest.TheEnum.class-object-for-TheEnum +//package rendererTest defined in root package +//internal final annotation class TheAnnotation defined in rendererTest +//public open class TheClass defined in rendererTest +// defined in rendererTest.TheClass +// defined in rendererTest.TheClass +//private final val privateVal : jet.Int defined in rendererTest.TheClass +//internal final val shouldBeFinal : jet.Int defined in rendererTest.TheClass +//protected abstract fun foo() : Unit defined in rendererTest.TheClass +//private final class Inner defined in rendererTest.TheClass +//internal final class InternalClass defined in rendererTest +//internal trait TheTrait defined in rendererTest +//internal abstract fun abstractFun() : Unit defined in rendererTest.TheTrait +//object : rendererTest.TheClass defined in rendererTest.TheTrait +//internal final fun classObjectFunction() : jet.Int defined in rendererTest.TheTrait. +//private final enum class TheEnum defined in rendererTest +//value-parameter val rgb : jet.Int defined in rendererTest.TheEnum. +//internal final class VAL1 : rendererTest.TheEnum defined in rendererTest.TheEnum.class-object-for-TheEnum +//internal final val VAL1 : rendererTest.TheEnum.class-object-for-TheEnum.VAL1 defined in rendererTest.TheEnum.class-object-for-TheEnum diff --git a/compiler/testData/renderer/FunctionTypes.kt b/compiler/testData/renderer/FunctionTypes.kt index 425c01d91be..9cb510a4e36 100644 --- a/compiler/testData/renderer/FunctionTypes.kt +++ b/compiler/testData/renderer/FunctionTypes.kt @@ -8,11 +8,11 @@ var v6 : Int.(String, Int) -> Unit var v7 : ExtensionFunction1 -//internal final var v1 : () -> Unit defined in . -//internal final var v2 : (jet.Int) -> jet.Int defined in . -//internal final var v3 : (jet.Int, #(jet.String, jet.String)) -> jet.String defined in . -//internal final var v4 : (jet.Int) -> jet.String defined in . -//internal final var v4 : (() -> jet.Int, (#(jet.String, jet.String)) -> Unit) -> jet.String defined in . -//internal final var v5 : jet.Int.() -> jet.Int defined in . -//internal final var v6 : jet.Int.(jet.String, jet.Int) -> Unit defined in . -//internal final var v7 : jet.Int.(jet.String) -> jet.Boolean defined in . +//internal final var v1 : () -> Unit defined in root package +//internal final var v2 : (jet.Int) -> jet.Int defined in root package +//internal final var v3 : (jet.Int, #(jet.String, jet.String)) -> jet.String defined in root package +//internal final var v4 : (jet.Int) -> jet.String defined in root package +//internal final var v4 : (() -> jet.Int, (#(jet.String, jet.String)) -> Unit) -> jet.String defined in root package +//internal final var v5 : jet.Int.() -> jet.Int defined in root package +//internal final var v6 : jet.Int.(jet.String, jet.Int) -> Unit defined in root package +//internal final var v7 : jet.Int.(jet.String) -> jet.Boolean defined in root package diff --git a/compiler/testData/renderer/GlobalFunctions.kt b/compiler/testData/renderer/GlobalFunctions.kt index 21a4d40204a..b2226aa8547 100644 --- a/compiler/testData/renderer/GlobalFunctions.kt +++ b/compiler/testData/renderer/GlobalFunctions.kt @@ -10,12 +10,17 @@ private fun prv(a : String, b : Int = 5) = 5 public fun Int.ext() : Int {} -//package rendererTest defined in . -//public final fun pub() : Unit defined in ..rendererTest -//internal final fun int() : jet.String defined in ..rendererTest -//internal final fun int2(val ints : jet.IntArray) : jet.Int defined in ..rendererTest -//value-parameter vararg val ints : jet.IntArray defined in ..rendererTest.int2 -//private final fun prv(val a : jet.String, val b : jet.Int = ...) : jet.Int defined in ..rendererTest -//value-parameter val a : jet.String defined in ..rendererTest.prv -//value-parameter val b : jet.Int defined in ..rendererTest.prv -//public final fun jet.Int.ext() : jet.Int defined in ..rendererTest \ No newline at end of file +public fun withTypeParam(a : Array) : Int {} + +//package rendererTest defined in root package +//public final fun pub() : Unit defined in rendererTest +//internal final fun int() : jet.String defined in rendererTest +//internal final fun int2(vararg ints : jet.Int) : jet.Int defined in rendererTest +//value-parameter vararg val ints : jet.Int defined in rendererTest.int2 +//private final fun prv(a : jet.String, b : jet.Int = ...) : jet.Int defined in rendererTest +//value-parameter val a : jet.String defined in rendererTest.prv +//value-parameter val b : jet.Int defined in rendererTest.prv +//public final fun jet.Int.ext() : jet.Int defined in rendererTest +//public final fun withTypeParam(a : jet.Array) : jet.Int defined in rendererTest +// defined in rendererTest.withTypeParam +//value-parameter val a : jet.Array defined in rendererTest.withTypeParam \ No newline at end of file diff --git a/compiler/testData/renderer/GlobalProperties.kt b/compiler/testData/renderer/GlobalProperties.kt index 943674128cd..25ff60f9d0a 100644 --- a/compiler/testData/renderer/GlobalProperties.kt +++ b/compiler/testData/renderer/GlobalProperties.kt @@ -11,10 +11,10 @@ private var private = 5 public val Int.ext : Int get() {} -//package rendererTest defined in . -//public final val pub : jet.String defined in ..rendererTest -//internal final var int : jet.String defined in ..rendererTest -//internal final val int2 : jet.Int defined in ..rendererTest -//private final var private : jet.Int defined in ..rendererTest -//public final val jet.Int.ext : jet.Int defined in ..rendererTest -//public final fun jet.Int.get-ext() : jet.Int defined in ..rendererTest \ No newline at end of file +//package rendererTest defined in root package +//public final val pub : jet.String defined in rendererTest +//internal final var int : jet.String defined in rendererTest +//internal final val int2 : jet.Int defined in rendererTest +//private final var private : jet.Int defined in rendererTest +//public final val jet.Int.ext : jet.Int defined in rendererTest +//public final fun jet.Int.get-ext() : jet.Int defined in rendererTest \ No newline at end of file diff --git a/compiler/testData/renderer/TupleTypes.kt b/compiler/testData/renderer/TupleTypes.kt index 73f1ecb3e50..184bf00bc9f 100644 --- a/compiler/testData/renderer/TupleTypes.kt +++ b/compiler/testData/renderer/TupleTypes.kt @@ -9,13 +9,13 @@ var v8 : #(Int, String, String) var v9 : Tuple2 var v10 : Tuple3? -//internal final var v1 : Unit defined in . -//internal final var v2 : Unit? defined in . -//internal final var v3 : Unit defined in . -//internal final var v4 : Unit? defined in . -//internal final var v5 : Unit defined in . -//internal final var v6 : #(jet.Int) defined in . -//internal final var v7 : #(jet.Int)? defined in . -//internal final var v8 : #(jet.Int, jet.String, jet.String) defined in . -//internal final var v9 : #(jet.Int, jet.String) defined in . -//internal final var v10 : #(jet.Int, jet.Int, jet.Int)? defined in . +//internal final var v1 : Unit defined in root package +//internal final var v2 : Unit? defined in root package +//internal final var v3 : Unit defined in root package +//internal final var v4 : Unit? defined in root package +//internal final var v5 : Unit defined in root package +//internal final var v6 : #(jet.Int) defined in root package +//internal final var v7 : #(jet.Int)? defined in root package +//internal final var v8 : #(jet.Int, jet.String, jet.String) defined in root package +//internal final var v9 : #(jet.Int, jet.String) defined in root package +//internal final var v10 : #(jet.Int, jet.Int, jet.Int)? defined in root package diff --git a/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java b/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java index e6178f6d2bd..d024dfd8572 100644 --- a/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java +++ b/compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java @@ -49,9 +49,10 @@ public class CompileCompilerDependenciesTest { * @see CompilerDependencies#compilerDependenciesForProduction(org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode) */ @NotNull - public static CompilerDependencies compilerDependenciesForTests(@NotNull CompilerSpecialMode compilerSpecialMode) { + public static CompilerDependencies compilerDependenciesForTests(@NotNull CompilerSpecialMode compilerSpecialMode, boolean mockJdk) { return new CompilerDependencies( compilerSpecialMode, + mockJdk ? JetTestUtils.findMockJdkRtJar() : CompilerDependencies.findRtJar(), compilerSpecialMode.includeJdkHeaders() ? ForTestCompileJdkHeaders.jdkHeadersForTests() : null, compilerSpecialMode.includeKotlinRuntime() ? ForTestCompileRuntime.runtimeJarForTests() : null); } diff --git a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java index 0591de3e22e..2c9d8af4e6d 100644 --- a/compiler/tests/org/jetbrains/jet/JetLiteFixture.java +++ b/compiler/tests/org/jetbrains/jet/JetLiteFixture.java @@ -30,8 +30,7 @@ import com.intellij.testFramework.LightVirtualFile; import com.intellij.testFramework.TestDataFile; import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NonNls; -import org.jetbrains.jet.compiler.CompileEnvironmentUtil; -import org.jetbrains.jet.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.plugin.JetLanguage; @@ -76,9 +75,7 @@ public abstract class JetLiteFixture extends UsefulTestCase { protected void createEnvironmentWithFullJdk() { myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); - final File rtJar = CompileEnvironmentUtil.findRtJar(); - myEnvironment.addToClasspath(rtJar); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false)); } @Override diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index 654499ce4d5..6bb5f8e7728 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -24,11 +24,12 @@ import com.intellij.openapi.util.io.FileUtil; import junit.framework.TestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.analyzer.AnalyzeExhaust; -import org.jetbrains.jet.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; +import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.Severity; -import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic; +import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -101,9 +102,8 @@ public class JetTestUtils { @Override public void report(@NotNull Diagnostic diagnostic) { - if (diagnostic instanceof UnresolvedReferenceDiagnostic) { - UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic)diagnostic; - throw new IllegalStateException("Unresolved: " + unresolvedReferenceDiagnostic.getPsiElement().getText()); + if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) { + throw new IllegalStateException("Unresolved: " + diagnostic.getPsiElement().getText()); } } }; @@ -153,14 +153,17 @@ public class JetTestUtils { @Override public void report(@NotNull Diagnostic diagnostic) { if (diagnostic.getSeverity() == Severity.ERROR) { - throw new IllegalStateException(diagnostic.getMessage()); + throw new IllegalStateException(DefaultErrorMessages.RENDERER.render(diagnostic)); } } }; + private JetTestUtils() { + } + public static AnalyzeExhaust analyzeFile(@NotNull JetFile namespace, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { return AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(namespace, flowDataTraceFactory, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); } public static JetCoreEnvironment createEnvironmentWithMockJdk(Disposable disposable) { @@ -168,11 +171,11 @@ public class JetTestUtils { } public static JetCoreEnvironment createEnvironmentWithMockJdk(Disposable disposable, @NotNull CompilerSpecialMode compilerSpecialMode) { - JetCoreEnvironment environment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode)); - final File rtJar = new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar"); - environment.addToClasspath(rtJar); - environment.addToClasspath(getAnnotationsJar()); - return environment; + return new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true)); + } + + public static File findMockJdkRtJar() { + return new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar"); } public static File getAnnotationsJar() { diff --git a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java index 875c4c69bac..1c447845f51 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/CheckerTestUtilTest.java @@ -101,7 +101,7 @@ public class CheckerTestUtilTest extends JetLiteFixture { public void test(final @NotNull PsiFile psiFile) { BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)) + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)) .getBindingContext(); String expectedText = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile)).toString(); diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java index a3d1fdb54f8..f1414d9cd17 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTest.java @@ -169,7 +169,7 @@ public class JetDiagnosticsTest extends JetLiteFixture { BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( getProject(), jetFiles, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)) + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)) .getBindingContext(); boolean ok = true; diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentTest.java similarity index 91% rename from compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentTest.java index 15258f3503a..57ddba262e0 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileEnvironmentTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentTest.java @@ -14,11 +14,12 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.openapi.util.io.FileUtil; import junit.framework.TestCase; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.common.ExitCode; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileJdkHeaders; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.parsing.JetParsingTest; @@ -45,12 +46,12 @@ public class CompileEnvironmentTest extends TestCase { File stdlib = ForTestCompileRuntime.runtimeJarForTests(); File jdkHeaders = ForTestCompileJdkHeaders.jdkHeadersForTests(); File resultJar = new File(tempDir, "result.jar"); - KotlinCompiler.ExitCode rv = new KotlinCompiler().exec(System.out, + ExitCode rv = new K2JVMCompiler().exec(System.out, "-module", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kts", "-jar", resultJar.getAbsolutePath(), "-stdlib", stdlib.getAbsolutePath(), "-jdkHeaders", jdkHeaders.getAbsolutePath()); - Assert.assertEquals("compilation completed with non-zero code", KotlinCompiler.ExitCode.OK, rv); + Assert.assertEquals("compilation completed with non-zero code", ExitCode.OK, rv); FileInputStream fileInputStream = new FileInputStream(resultJar); try { JarInputStream is = new JarInputStream(fileInputStream); @@ -78,10 +79,10 @@ public class CompileEnvironmentTest extends TestCase { File out = new File(tempDir, "out"); File stdlib = ForTestCompileRuntime.runtimeJarForTests(); File jdkHeaders = ForTestCompileJdkHeaders.jdkHeadersForTests(); - KotlinCompiler.ExitCode exitCode = new KotlinCompiler() + ExitCode exitCode = new K2JVMCompiler() .exec(System.out, "-src", JetParsingTest.getTestDataDir() + "/compiler/smoke/Smoke.kt", "-output", out.getAbsolutePath(), "-stdlib", stdlib.getAbsolutePath(), "-jdkHeaders", jdkHeaders.getAbsolutePath()); - Assert.assertEquals(KotlinCompiler.ExitCode.OK, exitCode); + Assert.assertEquals(ExitCode.OK, exitCode); assertEquals(1, out.listFiles().length); assertEquals(1, out.listFiles()[0].listFiles().length); } finally { diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileJavaAgainstKotlinTest.java similarity index 98% rename from compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileJavaAgainstKotlinTest.java index 7834b4ead9d..6f995fb3ff5 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileJavaAgainstKotlinTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.io.FileUtil; diff --git a/compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileKotlinAgainstKotlinTest.java similarity index 99% rename from compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileKotlinAgainstKotlinTest.java index 7eddece3513..d4fca06a78f 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/CompileKotlinAgainstKotlinTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.io.FileUtil; diff --git a/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java new file mode 100644 index 00000000000..d2f9e3ffc2d --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/JavaDescriptorResolverTest.java @@ -0,0 +1,72 @@ +/* + * 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.cli.jvm.compiler; + +import org.jetbrains.jet.CompileCompilerDependenciesTest; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; +import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.junit.Assert; + +import javax.tools.*; +import java.io.File; +import java.nio.charset.Charset; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Locale; + +/** + * @author Stepan Koltsov + * @see ReadJavaBinaryClassTest + */ +public class JavaDescriptorResolverTest extends TestCaseWithTmpdir { + + // This test can be implemented in ReadJavaBinaryClass test, but it is simpler here + public void testInner() throws Exception { + JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); + + StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, Locale.ENGLISH, Charset.forName("utf-8")); + try { + File file = new File("compiler/testData/javaDescriptorResolver/inner.java"); + Iterable javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(Collections.singleton(file)); + List options = Arrays.asList( + "-d", tmpdir.getPath() + ); + JavaCompiler.CompilationTask task = javaCompiler.getTask(null, fileManager, null, options, null, javaFileObjectsFromFiles); + + Assert.assertTrue(task.call()); + } finally { + fileManager.close(); + } + + JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdk(myTestRootDisposable, CompilerSpecialMode.JDK_HEADERS); + + jetCoreEnvironment.addToClasspath(tmpdir); + + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true), jetCoreEnvironment.getProject()); + JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName("A"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + Assert.assertNotNull(classDescriptor); + } + +} diff --git a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/NamespaceComparator.java similarity index 99% rename from compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/NamespaceComparator.java index e7e235e091b..e7be1728e58 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/NamespaceComparator.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.google.common.io.Files; import org.jetbrains.annotations.NotNull; diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java similarity index 96% rename from compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java index 251107a40a0..7e76f3be6dd 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadJavaBinaryClassTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.CharsetToolkit; @@ -86,7 +86,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( psiFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS)) + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true)) .getBindingContext(); return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel("test")); } @@ -114,7 +114,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS), jetCoreEnvironment.getProject()); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true), jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); } diff --git a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java similarity index 97% rename from compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java index cd07037c40b..a15d70efffc 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/ReadKotlinBinaryClassTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.io.FileUtil; @@ -90,7 +90,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { jetCoreEnvironment.addToClasspath(new File("out/production/runtime")); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS), jetCoreEnvironment.getProject()); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.JDK_HEADERS, true), jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); diff --git a/compiler/tests/org/jetbrains/jet/compiler/TestCaseWithTmpdir.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/TestCaseWithTmpdir.java similarity index 95% rename from compiler/tests/org/jetbrains/jet/compiler/TestCaseWithTmpdir.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/TestCaseWithTmpdir.java index f00189b4298..c3b7635b3a1 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/TestCaseWithTmpdir.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/TestCaseWithTmpdir.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.jet.JetTestUtils; diff --git a/compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/WriteSignatureTest.java similarity index 99% rename from compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/WriteSignatureTest.java index f09a6fa3a0f..9ffdf0eb2c1 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/WriteSignatureTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler; +package org.jetbrains.jet.cli.jvm.compiler; import com.google.common.io.Closeables; import com.google.common.io.Files; diff --git a/compiler/tests/org/jetbrains/jet/compiler/longTest/LibFromMaven.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/longTest/LibFromMaven.java similarity index 96% rename from compiler/tests/org/jetbrains/jet/compiler/longTest/LibFromMaven.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/longTest/LibFromMaven.java index f16c660f1da..d39b3ca3f80 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/longTest/LibFromMaven.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/longTest/LibFromMaven.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler.longTest; +package org.jetbrains.jet.cli.jvm.compiler.longTest; import org.jetbrains.annotations.NotNull; diff --git a/compiler/tests/org/jetbrains/jet/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java similarity index 97% rename from compiler/tests/org/jetbrains/jet/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java rename to compiler/tests/org/jetbrains/jet/cli/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java index a5b9c30a7ba..2351d449223 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java +++ b/compiler/tests/org/jetbrains/jet/cli/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.compiler.longTest; +package org.jetbrains.jet.cli.jvm.compiler.longTest; import com.google.common.io.ByteStreams; import com.intellij.openapi.Disposable; @@ -27,7 +27,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TimeUtils; -import org.jetbrains.jet.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.resolve.FqName; @@ -59,7 +59,7 @@ public class ResolveDescriptorsFromExternalLibraries { public ResolveDescriptorsFromExternalLibraries() { System.out.println("Getting compiler dependencies"); - compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR); + compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true); } private void run() throws Exception { diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java index c9f64026018..e95269f3368 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java @@ -127,7 +127,7 @@ public abstract class CodegenTestCase extends JetLiteFixture { private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) { final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( myFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false)); analyzeExhaust.throwIfError(); GenerationState state = new GenerationState(getProject(), classBuilderFactory, analyzeExhaust, Collections.singletonList(myFile)); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); diff --git a/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java b/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java index aacc2ca0d65..1e60a9fc01f 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CompileTextTest.java @@ -17,11 +17,11 @@ package org.jetbrains.jet.codegen; import org.jetbrains.jet.CompileCompilerDependenciesTest; -import org.jetbrains.jet.compiler.CompileEnvironmentConfiguration; -import org.jetbrains.jet.compiler.CompileEnvironmentUtil; -import org.jetbrains.jet.compiler.JetCoreEnvironment; -import org.jetbrains.jet.compiler.KotlinToJVMBytecodeCompiler; -import org.jetbrains.jet.compiler.messages.MessageCollector; +import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration; +import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; +import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; @@ -31,7 +31,7 @@ import java.lang.reflect.Method; public class CompileTextTest extends CodegenTestCase { public void testMe() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { String text = "import org.jetbrains.jet.codegen.CompileTextTest; fun x() = CompileTextTest()"; - CompilerDependencies dependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR); + CompilerDependencies dependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false); JetCoreEnvironment environment = new JetCoreEnvironment(CompileEnvironmentUtil.createMockDisposable(), dependencies); CompileEnvironmentConfiguration configuration = new CompileEnvironmentConfiguration(environment, dependencies, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR); configuration.getEnvironment().addToClasspathFromClassLoader(getClass().getClassLoader()); diff --git a/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java index 63f3b2c796c..6875096cb1c 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java @@ -38,7 +38,7 @@ public class GenerationUtils { public static GenerationState compileFileGetGenerationStateForTest(JetFile psiFile, @NotNull CompilerSpecialMode compilerSpecialMode) { final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( psiFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(compilerSpecialMode, true)); analyzeExhaust.throwIfError(); GenerationState state = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile)); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); diff --git a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java index 6ffbe45126b..fd581894162 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java @@ -23,9 +23,9 @@ import junit.framework.TestCase; import junit.framework.TestSuite; import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; -import org.jetbrains.jet.compiler.CompileEnvironmentConfiguration; -import org.jetbrains.jet.compiler.KotlinToJVMBytecodeCompiler; -import org.jetbrains.jet.compiler.messages.MessageCollector; +import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration; +import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler; +import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.psi.JetClass; import org.jetbrains.jet.lang.psi.JetDeclaration; @@ -75,7 +75,7 @@ public class TestlibTest extends CodegenTestCase { private TestSuite doBuildSuite() { try { - CompilerDependencies compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR); + CompilerDependencies compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, false); File junitJar = new File("libraries/lib/junit-4.9.jar"); if (!junitJar.exists()) { diff --git a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileBuiltins.java b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileBuiltins.java index 717df3be623..77ce6e88cfa 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileBuiltins.java +++ b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileBuiltins.java @@ -17,7 +17,8 @@ package org.jetbrains.jet.codegen.forTestCompile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.common.ExitCode; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import java.io.File; @@ -37,9 +38,9 @@ public class ForTestCompileBuiltins { @Override protected void doCompile(@NotNull File classesDir) throws Exception { - KotlinCompiler.ExitCode exitCode = new KotlinCompiler().exec( + ExitCode exitCode = new K2JVMCompiler().exec( System.err, "-output", classesDir.getPath(), "-src", "./compiler/frontend/src", "-mode", "builtins"); - if (exitCode != KotlinCompiler.ExitCode.OK) { + if (exitCode != ExitCode.OK) { throw new IllegalStateException("jdk headers compilation failed: " + exitCode); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileJdkHeaders.java b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileJdkHeaders.java index b12d967c733..7603af9ee1a 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileJdkHeaders.java +++ b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileJdkHeaders.java @@ -17,7 +17,8 @@ package org.jetbrains.jet.codegen.forTestCompile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.common.ExitCode; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import java.io.File; @@ -37,9 +38,9 @@ public class ForTestCompileJdkHeaders { @Override protected void doCompile(@NotNull File classesDir) throws Exception { - KotlinCompiler.ExitCode exitCode = new KotlinCompiler().exec( + ExitCode exitCode = new K2JVMCompiler().exec( System.err, "-output", classesDir.getPath(), "-src", "./jdk-headers/src", "-mode", "jdkHeaders"); - if (exitCode != KotlinCompiler.ExitCode.OK) { + if (exitCode != ExitCode.OK) { throw new IllegalStateException("jdk headers compilation failed: " + exitCode); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileRuntime.java b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileRuntime.java index b78a720c22a..dc8cb3569fe 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileRuntime.java +++ b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileRuntime.java @@ -16,12 +16,10 @@ package org.jetbrains.jet.codegen.forTestCompile; -import com.google.common.io.Files; -import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.io.FileUtil; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.common.ExitCode; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import org.junit.Assert; import javax.tools.JavaCompiler; @@ -29,12 +27,9 @@ import javax.tools.JavaFileObject; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; import java.io.File; -import java.io.FileOutputStream; import java.io.IOException; import java.nio.charset.Charset; import java.util.*; -import java.util.jar.JarEntry; -import java.util.jar.JarOutputStream; /** * Compile stdlib.jar that can be used in tests @@ -63,12 +58,12 @@ public class ForTestCompileRuntime { } private static void compileStdlib(File destdir) throws IOException { - KotlinCompiler.ExitCode exitCode = new KotlinCompiler().exec(System.err, + ExitCode exitCode = new K2JVMCompiler().exec(System.err, "-output", destdir.getPath(), "-src", "./libraries/stdlib/src", "-mode", "stdlib", "-classpath", "out/production/runtime"); - if (exitCode != KotlinCompiler.ExitCode.OK) { + if (exitCode != ExitCode.OK) { throw new IllegalStateException("stdlib for test compilation failed: " + exitCode); } } @@ -90,7 +85,15 @@ public class ForTestCompileRuntime { } private static void compileJavaPartOfBuiltins(File destdir) throws IOException { - JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); + if (true) { + FileUtil.copyDir(new File("out/production/runtime"), destdir); + } + else { + doCompileJavaPartOfBuiltins(destdir); + } + } + + private static void doCompileJavaPartOfBuiltins(File destdir) throws IOException {JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, Locale.ENGLISH, Charset.forName("utf-8")); try { diff --git a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileSomething.java b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileSomething.java index 174ffe669dc..c6d09a81878 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileSomething.java +++ b/compiler/tests/org/jetbrains/jet/codegen/forTestCompile/ForTestCompileSomething.java @@ -23,6 +23,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TimeUtils; +import java.io.BufferedOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; @@ -57,7 +58,7 @@ abstract class ForTestCompileSomething { FileOutputStream stdlibJar = new FileOutputStream(jarFile); try { - JarOutputStream jarOutputStream = new JarOutputStream(stdlibJar); + JarOutputStream jarOutputStream = new JarOutputStream(new BufferedOutputStream(stdlibJar)); try { copyToJar(classesDir, jarOutputStream); } diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 82aa49eedde..165332e7d03 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForTests { @@ -38,6 +39,9 @@ public class InjectorForTests { private CallResolver callResolver; private JetStandardLibrary jetStandardLibrary; private final Project project; + private AnnotationResolver annotationResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + private OverloadingConflictResolver overloadingConflictResolver; public InjectorForTests( @NotNull Project project @@ -48,9 +52,9 @@ public class InjectorForTests { this.callResolver = new CallResolver(); this.jetStandardLibrary = JetStandardLibrary.getInstance(); this.project = project; - AnnotationResolver annotationResolver = new AnnotationResolver(); - QualifiedExpressionResolver qualifiedExpressionResolver = new QualifiedExpressionResolver(); - OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); + this.annotationResolver = new AnnotationResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.overloadingConflictResolver = new OverloadingConflictResolver(); this.descriptorResolver.setAnnotationResolver(annotationResolver); this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); @@ -75,6 +79,10 @@ public class InjectorForTests { } + @PreDestroy + public void destroy() { + } + public DescriptorResolver getDescriptorResolver() { return this.descriptorResolver; } diff --git a/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java index 002543d7664..fb299b9a079 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java @@ -72,7 +72,7 @@ public class DescriptorRendererTest extends JetLiteFixture { AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( (JetFile) psiFile, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); final BindingContext bindingContext = analyzeExhaust.getBindingContext(); final List descriptors = new ArrayList(); psiFile.acceptChildren(new JetVisitorVoid() { diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 2be4be17768..f2d236a2e83 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -23,13 +23,15 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; -import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic; +import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; @@ -141,12 +143,11 @@ public abstract class ExpectedResolveData { AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, Predicates.alwaysTrue(), JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); BindingContext bindingContext = analyzeExhaust.getBindingContext(); for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { - if (diagnostic instanceof UnresolvedReferenceDiagnostic) { - UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic) diagnostic; - unresolvedReferences.add(unresolvedReferenceDiagnostic.getPsiElement()); + if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) { + unresolvedReferences.add(diagnostic.getPsiElement()); } } @@ -185,7 +186,7 @@ public abstract class ExpectedResolveData { assertTrue( "Must have been unresolved: " + renderReferenceInContext(referenceExpression) + - " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)), + " but was resolved to " + renderNullableDescriptor(bindingContext.get(REFERENCE_TARGET, referenceExpression)), unresolvedReferences.contains(referenceExpression)); continue; } @@ -193,7 +194,7 @@ public abstract class ExpectedResolveData { assertTrue( "Must have been resolved to multiple descriptors: " + renderReferenceInContext(referenceExpression) + - " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)), + " but was resolved to " + renderNullableDescriptor(bindingContext.get(REFERENCE_TARGET, referenceExpression)), bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, referenceExpression) != null); continue; } @@ -201,7 +202,7 @@ public abstract class ExpectedResolveData { assertTrue( "Must have been resolved to null: " + renderReferenceInContext(referenceExpression) + - " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)), + " but was resolved to " + renderNullableDescriptor(bindingContext.get(REFERENCE_TARGET, referenceExpression)), bindingContext.get(REFERENCE_TARGET, referenceExpression) == null ); continue; @@ -210,7 +211,7 @@ public abstract class ExpectedResolveData { assertTrue( "Must have been resolved to error: " + renderReferenceInContext(referenceExpression) + - " but was resolved to " + DescriptorRenderer.TEXT.render(bindingContext.get(REFERENCE_TARGET, referenceExpression)), + " but was resolved to " + renderNullableDescriptor(bindingContext.get(REFERENCE_TARGET, referenceExpression)), ErrorUtils.isError(bindingContext.get(REFERENCE_TARGET, referenceExpression)) ); continue; @@ -355,4 +356,9 @@ public abstract class ExpectedResolveData { T result = (T) element; return result; } + + @NotNull + private static String renderNullableDescriptor(@Nullable DeclarationDescriptor d) { + return d == null ? "" : DescriptorRenderer.TEXT.render(d); + } } diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 71abc9c1354..6540ba315cd 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -127,7 +127,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { private PsiClass findClass(String qualifiedName) { Project project = getProject(); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), project); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true), project); return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.THROW); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index fd69fc0031e..1a2a064a398 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -67,7 +67,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { assert aClass instanceof JetClass; AnalyzeExhaust bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(file, JetControlFlowDataTraceFactory.EMPTY, - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR)); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass); WritableScopeImpl scope = new WritableScopeImpl(libraryScope, root, RedeclarationHandler.DO_NOTHING); assert classDescriptor instanceof ClassifierDescriptor; diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 5416440ec5f..400b00ff07d 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -587,7 +587,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices( - CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR), getProject()); + CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true), getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope()); diff --git a/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/after.kt.template b/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/after.kt.template new file mode 100644 index 00000000000..d59bae419ce --- /dev/null +++ b/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/after.kt.template @@ -0,0 +1,3 @@ +fun main() { + val a : Array = array(1, 2, 3) +} \ No newline at end of file diff --git a/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/before.kt.template b/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/before.kt.template new file mode 100644 index 00000000000..747b9a65230 --- /dev/null +++ b/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/before.kt.template @@ -0,0 +1,3 @@ +fun main() { + val a = array(1, 2, 3) +} \ No newline at end of file diff --git a/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/description.html b/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/description.html new file mode 100644 index 00000000000..60e767f56aa --- /dev/null +++ b/idea/resources/intentionDescriptions/SpecifyTypeExplicitlyAction/description.html @@ -0,0 +1,5 @@ + + +This intention adds or removes explicit type specification for local values, variables and properties. + + \ No newline at end of file diff --git a/idea/resources/org/jetbrains/jet/plugin/icons/class_kotlin.png b/idea/resources/org/jetbrains/jet/plugin/icons/class_kotlin.png new file mode 100644 index 00000000000..84cfb2aadd5 Binary files /dev/null and b/idea/resources/org/jetbrains/jet/plugin/icons/class_kotlin.png differ diff --git a/idea/resources/org/jetbrains/jet/plugin/icons/kotlin.png b/idea/resources/org/jetbrains/jet/plugin/icons/kotlin.png new file mode 100644 index 00000000000..403a4e89325 Binary files /dev/null and b/idea/resources/org/jetbrains/jet/plugin/icons/kotlin.png differ diff --git a/idea/resources/org/jetbrains/jet/plugin/icons/kotlin_13.png b/idea/resources/org/jetbrains/jet/plugin/icons/kotlin_13.png new file mode 100644 index 00000000000..ad4ca9cbb87 Binary files /dev/null and b/idea/resources/org/jetbrains/jet/plugin/icons/kotlin_13.png differ diff --git a/idea/resources/org/jetbrains/jet/plugin/icons/kotlin_launch_configuration.png b/idea/resources/org/jetbrains/jet/plugin/icons/kotlin_launch_configuration.png new file mode 100644 index 00000000000..ab1407bb717 Binary files /dev/null and b/idea/resources/org/jetbrains/jet/plugin/icons/kotlin_launch_configuration.png differ diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index ace5239fa46..702cd766e88 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -133,8 +133,9 @@ - - + + + @@ -171,9 +172,13 @@ + + org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction + Kotlin + diff --git a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties index cf854a3e94c..d949b7cec59 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetBundle.properties +++ b/idea/src/org/jetbrains/jet/plugin/JetBundle.properties @@ -29,6 +29,9 @@ implement.members=Implement members new.kotlin.file.action=Kotlin File import.fix=Import imports.chooser.title=Imports +specify.type.explicitly.action.family.name=Specify Type Explicitly +specify.type.explicitly.add.action.name=Specify Type Explicitly +specify.type.explicitly.remove.action.name=Remove Explicitly Specified Type livetemplate.description.main=main() function livetemplate.description.soutp=Prints function parameter names and values to System.out diff --git a/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java b/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java index 1317a34b943..862eea63b29 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java @@ -92,7 +92,7 @@ public final class JetDescriptorIconProvider { case OBJECT: return JetIcons.OBJECT; case CLASS: - return PlatformIcons.CLASS_ICON; + return JetIcons.CLASS; default: LOG.warn("No icon for descriptor: " + descriptor); return null; diff --git a/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java b/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java index a237db389ea..1449d48d69e 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetIconProvider.java @@ -73,7 +73,7 @@ public class JetIconProvider extends IconProvider { return JetIcons.TRAIT; } - Icon icon = jetClass.hasModifier(JetTokens.ENUM_KEYWORD) ? PlatformIcons.ENUM_ICON : PlatformIcons.CLASS_ICON; + Icon icon = jetClass.hasModifier(JetTokens.ENUM_KEYWORD) ? PlatformIcons.ENUM_ICON : JetIcons.CLASS; if (jetClass instanceof JetEnumEntry) { JetEnumEntry enumEntry = (JetEnumEntry) jetClass; if (enumEntry.getPrimaryConstructorParameterList() == null) { diff --git a/idea/src/org/jetbrains/jet/plugin/JetIcons.java b/idea/src/org/jetbrains/jet/plugin/JetIcons.java index 8e9969cec3f..9b61eb3e9d6 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetIcons.java +++ b/idea/src/org/jetbrains/jet/plugin/JetIcons.java @@ -26,6 +26,7 @@ import javax.swing.*; public interface JetIcons { Icon SMALL_LOGO = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/kotlin16x16.png"); + Icon CLASS = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/class_kotlin.png"); Icon FILE = SMALL_LOGO; // TODO: Add file icon Icon OBJECT = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/object.png"); Icon TRAIT = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/trait.png"); @@ -36,4 +37,6 @@ public interface JetIcons { Icon PARAMETER = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/parameter.png"); Icon FIELD_VAL = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/field_value.png"); Icon FIELD_VAR = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/field_variable.png"); + + Icon LAUNCH = IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/kotlin_launch_configuration.png"); } diff --git a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java index 37c647ee4ff..890ea800949 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java @@ -37,12 +37,6 @@ import java.util.LinkedList; * @author svtk */ public class JetPluginUtil { - @NotNull - public static FqName computeTypeFullName(@NotNull JetType type) { - ClassDescriptor clazz = (ClassDescriptor) type.getConstructor().getDeclarationDescriptor(); - return DescriptorUtils.getFQName(clazz).toSafe(); - } - @NotNull private static LinkedList computeTypeFullNameList(JetType type) { if (type instanceof DeferredType) { diff --git a/idea/src/org/jetbrains/jet/plugin/actions/NewKotlinFileAction.java b/idea/src/org/jetbrains/jet/plugin/actions/NewKotlinFileAction.java index 1e1321f2836..31e7868df1e 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/NewKotlinFileAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/NewKotlinFileAction.java @@ -23,6 +23,7 @@ import com.intellij.psi.PsiDirectory; import com.intellij.util.PlatformIcons; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.JetFileType; +import org.jetbrains.jet.plugin.JetIcons; /** * @author Nikolay Krasko @@ -37,8 +38,8 @@ public class NewKotlinFileAction extends CreateFileFromTemplateAction { builder .setTitle(JetBundle.message("new.kotlin.file.action")) .addKind("Kotlin file", JetFileType.INSTANCE.getIcon(), "Kotlin File") - .addKind("Class", PlatformIcons.CLASS_ICON, "Kotlin Class") - .addKind("Trait", PlatformIcons.INTERFACE_ICON, "Kotlin Trait") + .addKind("Class", JetIcons.CLASS, "Kotlin Class") + .addKind("Trait", JetIcons.TRAIT, "Kotlin Trait") .addKind("Enum class", PlatformIcons.ENUM_ICON, "Kotlin Enum"); } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java index 6f8f844d7c6..f010af51727 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java @@ -24,6 +24,7 @@ import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.DialogWrapper; import com.intellij.openapi.util.Condition; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; @@ -33,15 +34,13 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper; import org.jetbrains.jet.resolve.DescriptorRenderer; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Set; +import java.util.*; /** * @author yole @@ -131,7 +130,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns } bodyBuilder.append(descriptor.getName()).append(" : ").append(DescriptorRenderer.COMPACT.renderTypeWithShortNames( descriptor.getType())); - ImportInsertHelper.addImportDirectiveIfNeeded(descriptor.getType(), file); + ImportInsertHelper.addImportDirectivesIfNeeded(descriptor.getType(), file); String initializer = defaultInitializer(descriptor.getType(), JetStandardLibrary.getInstance()); if (initializer != null) { bodyBuilder.append(" = ").append(initializer); @@ -145,7 +144,40 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns private static JetElement overrideFunction(Project project, JetFile file, SimpleFunctionDescriptor descriptor) { StringBuilder bodyBuilder = new StringBuilder(); bodyBuilder.append(displayableVisibility(descriptor)); - bodyBuilder.append("override fun ").append(descriptor.getName()).append("("); + bodyBuilder.append("override fun "); + + List whereRestrictions = new ArrayList(); + if (!descriptor.getTypeParameters().isEmpty()) { + bodyBuilder.append("<"); + boolean first = true; + for (TypeParameterDescriptor param : descriptor.getTypeParameters()) { + if (!first) { + bodyBuilder.append(", "); + } + + bodyBuilder.append(param.getName()); + Set upperBounds = param.getUpperBounds(); + if (!upperBounds.isEmpty()) { + boolean firstUpperBound = true; + for (JetType upperBound : upperBounds) { + String upperBoundText = " : " + DescriptorRenderer.TEXT.renderTypeWithShortNames(upperBound); + if (upperBound != JetStandardClasses.getDefaultBound()) { + if (firstUpperBound) { + bodyBuilder.append(upperBoundText); + } else { + whereRestrictions.add(param.getName() + upperBoundText); + } + } + ImportInsertHelper.addImportDirectivesIfNeeded(upperBound, file); + firstUpperBound = false; + } + } + + first = false; + } + bodyBuilder.append("> "); + } + bodyBuilder.append(descriptor.getName()).append("("); boolean isAbstractFun = descriptor.getModality() == Modality.ABSTRACT; StringBuilder delegationBuilder = new StringBuilder(); if (isAbstractFun) { @@ -166,9 +198,9 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns first = false; bodyBuilder.append(parameterDescriptor.getName()); bodyBuilder.append(" : "); - bodyBuilder.append(DescriptorRenderer.COMPACT.renderTypeWithShortNames(parameterDescriptor.getType())); + bodyBuilder.append(DescriptorRenderer.TEXT.renderTypeWithShortNames(parameterDescriptor.getType())); - ImportInsertHelper.addImportDirectiveIfNeeded(parameterDescriptor.getType(), file); + ImportInsertHelper.addImportDirectivesIfNeeded(parameterDescriptor.getType(), file); if (!isAbstractFun) { delegationBuilder.append(parameterDescriptor.getName()); @@ -183,10 +215,12 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns boolean returnsNotUnit = returnType != null && !stdlib.getTuple0Type().equals(returnType); if (returnsNotUnit) { - bodyBuilder.append(" : ").append(DescriptorRenderer.COMPACT.renderTypeWithShortNames(returnType)); - ImportInsertHelper.addImportDirectiveIfNeeded(returnType, file); + bodyBuilder.append(" : ").append(DescriptorRenderer.TEXT.renderTypeWithShortNames(returnType)); + ImportInsertHelper.addImportDirectivesIfNeeded(returnType, file); + } + if (!whereRestrictions.isEmpty()) { + bodyBuilder.append("\n").append("where ").append(StringUtil.join(whereRestrictions, ", ")); } - bodyBuilder.append("{").append(returnsNotUnit && !isAbstractFun ? "return " : "").append(delegationBuilder.toString()).append("}"); return JetPsiFactory.createFunction(project, bodyBuilder.toString()); diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java index 6e337505b1e..b6336e54af4 100644 --- a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java +++ b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompiler.java @@ -16,13 +16,14 @@ package org.jetbrains.jet.plugin.compiler; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; import com.google.common.collect.Sets; import com.intellij.compiler.impl.javaCompiler.ModuleChunk; import com.intellij.compiler.impl.javaCompiler.OutputItemImpl; import com.intellij.execution.configurations.GeneralCommandLine; import com.intellij.execution.configurations.SimpleJavaParameters; -import com.intellij.execution.process.*; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.compiler.CompileContext; import com.intellij.openapi.compiler.CompileScope; import com.intellij.openapi.compiler.CompilerMessageCategory; @@ -30,11 +31,11 @@ import com.intellij.openapi.compiler.TranslatingCompiler; import com.intellij.openapi.compiler.ex.CompileContextEx; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; import com.intellij.openapi.projectRoots.JavaSdkType; import com.intellij.openapi.projectRoots.JdkUtil; import com.intellij.openapi.projectRoots.Sdk; import com.intellij.openapi.projectRoots.SimpleJavaSdkType; -import com.intellij.openapi.util.Key; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VirtualFile; @@ -43,18 +44,22 @@ import com.intellij.util.SystemProperties; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.plugin.JetFileType; +import org.jetbrains.jet.plugin.project.JsModuleDetector; import org.jetbrains.jet.utils.PathUtil; +import org.xml.sax.Attributes; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.helpers.DefaultHandler; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; import java.io.*; import java.lang.ref.SoftReference; import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; -import java.nio.charset.Charset; import java.util.*; -import java.util.regex.Matcher; -import java.util.regex.Pattern; import static com.intellij.openapi.compiler.CompilerMessageCategory.*; @@ -68,7 +73,14 @@ public class JetCompiler implements TranslatingCompiler { @Override public boolean isCompilableFile(VirtualFile virtualFile, CompileContext compileContext) { - return virtualFile.getFileType() instanceof JetFileType; + if (!(virtualFile.getFileType() instanceof JetFileType)) { + return false; + } + Project project = compileContext.getProject(); + if (project == null || JsModuleDetector.isJsProject(project)) { + return false; + } + return true; } @NotNull @@ -138,7 +150,7 @@ public class JetCompiler implements TranslatingCompiler { return; } - OutputItemsCollector collector = new OutputItemsCollector(outputDir.getPath()); + OutputItemsCollectorImpl collector = new OutputItemsCollectorImpl(outputDir.getPath()); if (RUN_OUT_OF_PROCESS) { runOutOfProcess(compileContext, collector, outputDir, kotlinHome, scriptFile); @@ -235,47 +247,97 @@ public class JetCompiler implements TranslatingCompiler { return answer; } - private void runInProcess(CompileContext compileContext, OutputItemsCollector collector, VirtualFile outputDir, File kotlinHome, File scriptFile) { + private void runInProcess(final CompileContext compileContext, OutputItemsCollector collector, VirtualFile outputDir, File kotlinHome, File scriptFile) { ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); PrintStream out = new PrintStream(outputStream); - int rc = execInProcess(kotlinHome, outputDir, scriptFile, out, compileContext); - - ProcessAdapter listener = createProcessListener(compileContext, collector); + int exitCode = execInProcess(kotlinHome, outputDir, scriptFile, out, compileContext); BufferedReader reader = new BufferedReader(new StringReader(outputStream.toString())); - while (true) { - try { - String line = reader.readLine(); - if (line == null) break; - listener.onTextAvailable(new ProcessEvent(NullProcessHandler.INSTANCE, line + "\n"), ProcessOutputTypes.STDERR); - } catch (IOException e) { - // Can't be - throw new IllegalStateException(e); - } - } + parseCompilerMessagesFromReader(compileContext, reader, collector); + handleProcessTermination(exitCode, compileContext); + } - ProcessEvent termintationEvent = new ProcessEvent(NullProcessHandler.INSTANCE, rc); - listener.processWillTerminate(termintationEvent, false); - listener.processTerminated(termintationEvent); + private static void parseCompilerMessagesFromReader(CompileContext compileContext, final Reader reader, OutputItemsCollector collector) { + // Sometimes the compiler can't output valid XML + // Example: error in command line arguments passed to the compiler + // having no -tags key (arguments are not parsed), the compiler doesn't know + // if it should put any tags in the output, so it will simply print the usage + // and the SAX parser will break. + // In this case, we want to read everything from this stream + // and report it as an IDE error. + final StringBuilder stringBuilder = new StringBuilder(); + //noinspection IOResourceOpenedButNotSafelyClosed + Reader wrappingReader = new Reader() { + + @Override + public int read(char[] cbuf, int off, int len) throws IOException { + int read = reader.read(cbuf, off, len); + stringBuilder.append(cbuf, off, len); + return read; + } + + @Override + public void close() throws IOException { + // Do nothing: + // If the SAX parser sees a syntax error, it throws an expcetion + // and calls close() on the reader. + // We prevent hte reader from being closed here, and close it later, + // when all the text is read from it + } + }; + try { + SAXParserFactory factory = SAXParserFactory.newInstance(); + SAXParser parser = factory.newSAXParser(); + parser.parse(new InputSource(wrappingReader), new CompilerOutputSAXHandler(compileContext, collector)); + } + catch (Throwable e) { + + // Load all the text into the stringBuilder + try { + // This will not close the reader (see the wrapper above) + FileUtil.loadTextAndClose(wrappingReader); + } + catch (IOException ioException) { + LOG.error(ioException); + } + String message = stringBuilder.toString(); + LOG.error(message); + LOG.error(e); + compileContext.addMessage(ERROR, message, null, -1, -1); + } + finally { + try { + reader.close(); + } + catch (IOException e) { + LOG.error(e); + } + } + } + + private static void handleProcessTermination(int exitCode, CompileContext compileContext) { + if (exitCode != 0 && exitCode != 1) { + compileContext.addMessage(ERROR, "Compiler terminated with exit code: " + exitCode, "", -1, -1); + } } private static int execInProcess(File kotlinHome, VirtualFile outputDir, File scriptFile, PrintStream out, CompileContext context) { URLClassLoader loader = getOrCreateClassLoader(kotlinHome, context); try { - String compilerClassName = "org.jetbrains.jet.cli.KotlinCompiler"; + String compilerClassName = "org.jetbrains.jet.cli.jvm.K2JVMCompiler"; Class kompiler = Class.forName(compilerClassName, true, loader); Method exec = kompiler.getDeclaredMethod("exec", PrintStream.class, String[].class); - String[] arguments = { "-module", scriptFile.getAbsolutePath(), "-output", path(outputDir), "-tags", "-verbose", "-version", "-mode", "stdlib" }; + String[] arguments = commandLineArguments(outputDir, scriptFile); context.addMessage(INFORMATION, "Using kotlinHome=" + kotlinHome, "", -1, -1); context.addMessage(INFORMATION, "Invoking in-process compiler " + compilerClassName + " with arguments " + Arrays.asList(arguments), "", -1, -1); Object rc = exec.invoke(kompiler.newInstance(), out, arguments); - // exec() returns a KotlinCompiler.ExitCode object, that class is not accessible here, + // exec() returns a K2JVMCompiler.ExitCode object, that class is not accessible here, // so we take it's contents through reflection - if ("org.jetbrains.jet.cli.KotlinCompiler.ExitCode".equals(rc.getClass().getCanonicalName())) { + if ("org.jetbrains.jet.cli.jvm.K2JVMCompiler.ExitCode".equals(rc.getClass().getCanonicalName())) { return (Integer) rc.getClass().getMethod("getCode").invoke(rc); } else { @@ -287,6 +349,10 @@ public class JetCompiler implements TranslatingCompiler { } } + private static String[] commandLineArguments(VirtualFile outputDir, File scriptFile) { + return new String[]{ "-module", scriptFile.getAbsolutePath(), "-output", path(outputDir), "-tags", "-verbose", "-version", "-mode", "stdlib" }; + } + private static SoftReference ourClassLoaderRef = new SoftReference(null); private static URLClassLoader getOrCreateClassLoader(File kotlinHome, CompileContext context) { @@ -312,14 +378,14 @@ public class JetCompiler implements TranslatingCompiler { return new URLClassLoader(urls, null); } - private static void runOutOfProcess(CompileContext compileContext, OutputItemsCollector collector, VirtualFile outputDir, File kotlinHome, File scriptFile) { + private static void runOutOfProcess(final CompileContext compileContext, final OutputItemsCollector collector, VirtualFile outputDir, File kotlinHome, File scriptFile) { final SimpleJavaParameters params = new SimpleJavaParameters(); params.setJdk(new SimpleJavaSdkType().createJdk("tmp", SystemProperties.getJavaHome())); - params.setMainClass("org.jetbrains.jet.cli.KotlinCompiler"); - params.getProgramParametersList().add("-module", scriptFile.getAbsolutePath()); - params.getProgramParametersList().add("-output", path(outputDir)); - params.getProgramParametersList().add("-tags"); - params.getProgramParametersList().add("-verbose"); + params.setMainClass("org.jetbrains.jet.cli.jvm.K2JVMCompiler"); + + for (String arg : commandLineArguments(outputDir, scriptFile)) { + params.getProgramParametersList().add(arg); + } for (File jar : kompilerClasspath(kotlinHome, compileContext)) { params.getClassPath().add(jar); @@ -336,25 +402,37 @@ public class JetCompiler implements TranslatingCompiler { compileContext.addMessage(INFORMATION, "Invoking out-of-process compiler with arguments: " + commandLine, "", -1, -1); try { - final OSProcessHandler processHandler = new OSProcessHandler(commandLine.createProcess(), commandLine.getCommandLineString()) { - @Override - public Charset getCharset() { - return commandLine.getCharset(); - } - }; + final Process process = commandLine.createProcess(); - ProcessAdapter processListener = createProcessListener(compileContext, collector); - processHandler.addProcessListener(processListener); + ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { + @Override + public void run() { + parseCompilerMessagesFromReader(compileContext, new InputStreamReader(process.getInputStream()), collector); + } + }); - processHandler.startNotify(); - processHandler.waitFor(); - } catch (Exception e) { + ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { + @Override + public void run() { + try { + FileUtil.loadBytes(process.getErrorStream()); + } + catch (IOException e) { + // Don't care + } + } + }); + + int exitCode = process.waitFor(); + handleProcessTermination(exitCode, compileContext); + } + catch (Exception e) { compileContext.addMessage(ERROR, "[Internal Error] " + e.getLocalizedMessage(), "", -1, -1); return; } } - private static class OutputItemsCollector { + public static class OutputItemsCollectorImpl implements OutputItemsCollector { private static final String FOR_SOURCE_PREFIX = "For source: "; private static final String EMITTING_PREFIX = "Emitting: "; private final String outputPath; @@ -362,10 +440,11 @@ public class JetCompiler implements TranslatingCompiler { private List answer = new ArrayList(); private List sources = new ArrayList(); - private OutputItemsCollector(String outputPath) { + public OutputItemsCollectorImpl(String outputPath) { this.outputPath = outputPath; } + @Override public void learn(String message) { message = message.trim(); if (message.startsWith(FOR_SOURCE_PREFIX)) { @@ -376,7 +455,9 @@ public class JetCompiler implements TranslatingCompiler { } else if (message.startsWith(EMITTING_PREFIX)) { if (currentSource != null) { - answer.add(new OutputItemImpl(outputPath + "/" + message.substring(EMITTING_PREFIX.length()), currentSource)); + OutputItemImpl item = new OutputItemImpl(outputPath + "/" + message.substring(EMITTING_PREFIX.length()), currentSource); + LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(item.getOutputPath())); + answer.add(item); } } } @@ -390,10 +471,6 @@ public class JetCompiler implements TranslatingCompiler { } } - private static ProcessAdapter createProcessListener(final CompileContext compileContext, OutputItemsCollector collector) { - return new CompilerProcessListener(compileContext, collector); - } - private static String path(VirtualFile root) { String path = root.getPath(); if (path.endsWith("!/")) { @@ -403,211 +480,93 @@ public class JetCompiler implements TranslatingCompiler { return path; } - private static class NullProcessHandler extends ProcessHandler { - public static NullProcessHandler INSTANCE = new NullProcessHandler(); - @Override - protected void destroyProcessImpl() { - throw new UnsupportedOperationException("destroyProcessImpl is not implemented"); - } - - @Override - protected void detachProcessImpl() { - throw new UnsupportedOperationException("detachProcessImpl is not implemented"); // TODO - } - - @Override - public boolean detachIsDefault() { - throw new UnsupportedOperationException("detachIsDefault is not implemented"); - } - - @Override - public OutputStream getProcessInput() { - throw new UnsupportedOperationException("getProcessInput is not implemented"); - } - } - - private static class CompilerProcessListener extends ProcessAdapter { - private static final Pattern DIAGNOSTIC_PATTERN = Pattern.compile("<(ERROR|WARNING|INFO|EXCEPTION|LOGGING)", Pattern.MULTILINE); - private static final Pattern OPEN_TAG_END_PATTERN = Pattern.compile(">", Pattern.MULTILINE | Pattern.DOTALL); - private static final Pattern ATTRIBUTE_PATTERN = Pattern.compile("\\s*(path|line|column)\\s*=\\s*\"(.*?)\"", Pattern.MULTILINE | Pattern.DOTALL); - private static final Pattern MESSAGE_PATTERN = Pattern.compile("(.*?)", Pattern.MULTILINE | Pattern.DOTALL); - - private enum State { - WAITING, ATTRIBUTES, MESSAGE - } - - private static class CompilerMessage { - private CompilerMessageCategory messageCategory; - private boolean isException; - private @Nullable String url; - private @Nullable Integer line; - private @Nullable Integer column; - private String message; - - public void setMessageCategoryFromString(String tagName) { - if ("ERROR".equals(tagName)) { - messageCategory = ERROR; - } - else if ("EXCEPTION".equals(tagName)) { - messageCategory = ERROR; - isException = true; - } - else if ("WARNING".equals(tagName)) { - messageCategory = WARNING; - } - else if ("LOGGING".equals(tagName)) { - messageCategory = STATISTICS; - } - else { - messageCategory = INFORMATION; - } - } - - public void setAttributeFromStrings(String name, String value) { - if ("path".equals(name)) { - url = "file://" + value.trim(); - } - else if ("line".equals(name)) { - line = safeParseInt(value); - } - else if ("column".equals(name)) { - column = safeParseInt(value); - } - } - - @Nullable - private static Integer safeParseInt(String value) { - try { - return Integer.parseInt(value.trim()); - } - catch (NumberFormatException e) { - return null; - } - } - - public void setMessage(String message) { - this.message = message; - } - - public void reportTo(CompileContext compileContext) { - if (messageCategory == STATISTICS) { - compileContext.getProgressIndicator().setText(message); - } - else { - compileContext.addMessage(messageCategory, message, url == null ? "" : url, line == null ? -1 : line, - column == null - ? -1 - : column); - if (isException) { - LOG.error(message); - } - } - } - } + private static class CompilerOutputSAXHandler extends DefaultHandler { + private static final Map CATEGORIES = ImmutableMap.builder() + .put("error", CompilerMessageCategory.ERROR) + .put("warning", CompilerMessageCategory.WARNING) + .put("logging", CompilerMessageCategory.STATISTICS) + .put("exception", CompilerMessageCategory.ERROR) + .put("info", CompilerMessageCategory.INFORMATION) + .put("messages", CompilerMessageCategory.INFORMATION) // Root XML element + .build(); private final CompileContext compileContext; private final OutputItemsCollector collector; - private final StringBuilder output = new StringBuilder(); - private int firstUnprocessedIndex = 0; - private State state = State.WAITING; - private CompilerMessage currentCompilerMessage; - public CompilerProcessListener(CompileContext compileContext, OutputItemsCollector collector) { + private final StringBuilder message = new StringBuilder(); + private Stack tags = new Stack(); + private String path; + private int line; + private int column; + + public CompilerOutputSAXHandler(CompileContext compileContext, OutputItemsCollector collector) { this.compileContext = compileContext; this.collector = collector; } @Override - public void onTextAvailable(ProcessEvent event, Key outputType) { - String text = event.getText(); - if (outputType == ProcessOutputTypes.STDERR) { - output.append(text); + public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { + tags.push(qName); - // We loop until the state stabilizes - State lastState; - do { - lastState = state; - switch (state) { - case WAITING: { - Matcher matcher = matcher(DIAGNOSTIC_PATTERN); - if (find(matcher)) { - currentCompilerMessage = new CompilerMessage(); - currentCompilerMessage.setMessageCategoryFromString(matcher.group(1)); - state = State.ATTRIBUTES; - } - break; - } - case ATTRIBUTES: { - Matcher matcher = matcher(ATTRIBUTE_PATTERN); - int indexDelta = 0; - while (matcher.find()) { - handleSkippedOutput(output.subSequence(firstUnprocessedIndex + indexDelta, firstUnprocessedIndex + matcher.start())); - currentCompilerMessage.setAttributeFromStrings(matcher.group(1), matcher.group(2)); - indexDelta = matcher.end(); + message.setLength(0); - } - firstUnprocessedIndex += indexDelta; - - Matcher endMatcher = matcher(OPEN_TAG_END_PATTERN); - if (find(endMatcher)) { - state = State.MESSAGE; - } - break; - } - case MESSAGE: { - Matcher matcher = matcher(MESSAGE_PATTERN); - if (find(matcher)) { - String message = matcher.group(1); - currentCompilerMessage.setMessage(message); - currentCompilerMessage.reportTo(compileContext); - - if (currentCompilerMessage.messageCategory == STATISTICS) { - collector.learn(message); - } - - state = State.WAITING; - } - break; - } - } - } - while (state != lastState); - - } - else { - compileContext.addMessage(INFORMATION, text, "", -1, -1); - } - } - - private boolean find(Matcher matcher) { - boolean result = matcher.find(); - if (result) { - handleSkippedOutput(output.subSequence(firstUnprocessedIndex, firstUnprocessedIndex + matcher.start())); - firstUnprocessedIndex += matcher.end(); - } - return result; - } - - private Matcher matcher(Pattern pattern) { - return pattern.matcher(output.subSequence(firstUnprocessedIndex, output.length())); + String rawPath = attributes.getValue("path"); + path = rawPath == null ? null : "file://" + rawPath; + line = safeParseInt(attributes.getValue("line"), -1); + column = safeParseInt(attributes.getValue("column"), -1); } @Override - public void processTerminated(ProcessEvent event) { - if (firstUnprocessedIndex < output.length()) { - handleSkippedOutput(output.substring(firstUnprocessedIndex).trim()); + public void characters(char[] ch, int start, int length) throws SAXException { + if (tags.size() == 1) { + // We're directly inside the root tag: + String message = new String(ch, start, length); + if (!message.trim().isEmpty()) { + compileContext.addMessage(ERROR, "Unhandled compiler output: " + message, null, -1, -1); + } } - int exitCode = event.getExitCode(); - // 0 is normal, 1 is "errors found" - handled by the messages above - if (exitCode != 0 && exitCode != 1) { - compileContext.addMessage(ERROR, "Compiler terminated with exit code: " + exitCode, "", -1, -1); + else { + message.append(ch, start, length); } } - private void handleSkippedOutput(CharSequence substring) { - String message = substring.toString(); - if (!message.trim().isEmpty()) { - compileContext.addMessage(ERROR, message, "", -1, -1); + @Override + public void endElement(String uri, String localName, String qName) throws SAXException { + if (tags.size() == 1) { + // We're directly inside the root tag: + return; + } + String qNameLowerCase = qName.toLowerCase(); + CompilerMessageCategory category = CATEGORIES.get(qNameLowerCase); + if (category == null) { + compileContext.addMessage(ERROR, "Unknown compiler message tag: " + qName, null, -1, -1); + category = INFORMATION; + } + String text = message.toString(); + + if ("exception".equals(qNameLowerCase)) { + LOG.error(text); + } + + if (category == STATISTICS) { + compileContext.getProgressIndicator().setText(text); + collector.learn(text); + } + else { + compileContext.addMessage(category, text, path, line, column); + } + tags.pop(); + } + + private static int safeParseInt(@Nullable String value, int defaultValue) { + if (value == null) { + return defaultValue; + } + try { + return Integer.parseInt(value.trim()); + } + catch (NumberFormatException e) { + return defaultValue; } } } diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompilerManager.java b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompilerManager.java index d08b047218a..71fd5b79333 100644 --- a/idea/src/org/jetbrains/jet/plugin/compiler/JetCompilerManager.java +++ b/idea/src/org/jetbrains/jet/plugin/compiler/JetCompilerManager.java @@ -31,8 +31,11 @@ import java.util.Collections; public class JetCompilerManager implements ProjectComponent { public JetCompilerManager(CompilerManager manager) { manager.addTranslatingCompiler(new JetCompiler(), - Collections.singleton(JetFileType.INSTANCE), - Collections.singleton(StdFileTypes.CLASS)); + Collections.singleton(JetFileType.INSTANCE), + Collections.singleton(StdFileTypes.CLASS)); + manager.addTranslatingCompiler(new K2JSCompiler(), + Collections.singleton(JetFileType.INSTANCE), + Collections.singleton(StdFileTypes.JS)); manager.addCompilableFileType(JetFileType.INSTANCE); } diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java b/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java new file mode 100644 index 00000000000..ca8f5e0bb58 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/compiler/K2JSCompiler.java @@ -0,0 +1,64 @@ +/* + * 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.plugin.compiler; + +import com.intellij.openapi.compiler.CompileContext; +import com.intellij.openapi.compiler.CompileScope; +import com.intellij.openapi.compiler.CompilerMessageCategory; +import com.intellij.openapi.compiler.TranslatingCompiler; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.util.Chunk; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.plugin.JetFileType; +import org.jetbrains.jet.plugin.project.JsModuleDetector; + +/** + * @author Pavel Talanov + */ +public final class K2JSCompiler implements TranslatingCompiler { + + @Override + public boolean isCompilableFile(VirtualFile file, CompileContext context) { + if (!(file.getFileType() instanceof JetFileType)) { + return false; + } + Project project = context.getProject(); + if (project == null) { + return false; + } + return JsModuleDetector.isJsProject(project); + } + + @Override + public void compile(final CompileContext context, Chunk moduleChunk, final VirtualFile[] files, OutputSink sink) { + context.addMessage(CompilerMessageCategory.INFORMATION, "Some useful code will be there", null, -1, -1); + //TODO: + } + + @NotNull + @Override + public String getDescription() { + return "Kotlin to JavaScript compiler"; + } + + @Override + public boolean validateConfiguration(CompileScope scope) { + return true; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/compiler/OutputItemsCollector.java b/idea/src/org/jetbrains/jet/plugin/compiler/OutputItemsCollector.java new file mode 100644 index 00000000000..49bf2881b77 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/compiler/OutputItemsCollector.java @@ -0,0 +1,24 @@ +/* + * 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.plugin.compiler; + +/** + * @author abreslav + */ +public interface OutputItemsCollector { + void learn(String message); +} diff --git a/idea/src/org/jetbrains/jet/plugin/completion/JetCompletionContributor.java b/idea/src/org/jetbrains/jet/plugin/completion/JetCompletionContributor.java index 1c4907a2247..a57ba5fcb71 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/JetCompletionContributor.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/JetCompletionContributor.java @@ -31,7 +31,7 @@ import com.intellij.util.Consumer; import com.intellij.util.ProcessingContext; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.compiler.TipsManager; +import org.jetbrains.jet.cli.jvm.compiler.TipsManager; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; diff --git a/idea/src/org/jetbrains/jet/plugin/completion/JetPackagesContributor.java b/idea/src/org/jetbrains/jet/plugin/completion/JetPackagesContributor.java index 4fbf325a7ae..955a72f1568 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/JetPackagesContributor.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/JetPackagesContributor.java @@ -24,7 +24,7 @@ import com.intellij.psi.PsiReference; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.ProcessingContext; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.compiler.TipsManager; +import org.jetbrains.jet.cli.jvm.compiler.TipsManager; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespaceHeader; import org.jetbrains.jet.lang.resolve.BindingContext; diff --git a/idea/src/org/jetbrains/jet/plugin/JetCodeBlockSelectioner.java b/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetCodeBlockSelectioner.java similarity index 98% rename from idea/src/org/jetbrains/jet/plugin/JetCodeBlockSelectioner.java rename to idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetCodeBlockSelectioner.java index 4165c9a182b..e961a52e7f5 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetCodeBlockSelectioner.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetCodeBlockSelectioner.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jetbrains.jet.plugin; +package org.jetbrains.jet.plugin.editor.wordSelection; import com.intellij.codeInsight.editorActions.wordSelection.BasicSelectioner; import com.intellij.lang.ASTNode; diff --git a/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetListSelectioner.java b/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetListSelectioner.java new file mode 100644 index 00000000000..09ac4a416dd --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetListSelectioner.java @@ -0,0 +1,56 @@ +/* + * 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.plugin.editor.wordSelection; + +import com.intellij.codeInsight.editorActions.wordSelection.BasicSelectioner; +import com.intellij.lang.ASTNode; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiElement; +import com.intellij.psi.tree.TokenSet; +import org.jetbrains.jet.lang.psi.JetParameterList; +import org.jetbrains.jet.lang.psi.JetTypeArgumentList; +import org.jetbrains.jet.lang.psi.JetTypeParameterList; +import org.jetbrains.jet.lang.psi.JetValueArgumentList; +import org.jetbrains.jet.lexer.JetTokens; + +import java.util.Arrays; +import java.util.List; + +/** + * @author Evgeny Gerashchenko + * @since 4/23/12 + */ +public class JetListSelectioner extends BasicSelectioner { + @Override + public boolean canSelect(PsiElement e) { + return e instanceof JetParameterList || e instanceof JetValueArgumentList || + e instanceof JetTypeParameterList || e instanceof JetTypeArgumentList; + } + + @Override + public List select(PsiElement e, CharSequence editorText, int cursorOffset, Editor editor) { + ASTNode node = e.getNode(); + ASTNode startNode = node.findChildByType(TokenSet.create(JetTokens.LPAR, JetTokens.LT)); + ASTNode endNode = node.findChildByType(TokenSet.create(JetTokens.RPAR, JetTokens.GT)); + if (startNode != null && endNode != null) { + return Arrays.asList(new TextRange(startNode.getStartOffset() + 1, endNode.getStartOffset())); + } else { + return Arrays.asList(); + } + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/JetStatementGroupSelectioner.java b/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetStatementGroupSelectioner.java similarity index 98% rename from idea/src/org/jetbrains/jet/plugin/JetStatementGroupSelectioner.java rename to idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetStatementGroupSelectioner.java index 4d10cf5538e..f98999f0410 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetStatementGroupSelectioner.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/wordSelection/JetStatementGroupSelectioner.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.jet.plugin; +package org.jetbrains.jet.plugin.editor.wordSelection; import com.intellij.codeInsight.editorActions.wordSelection.BasicSelectioner; import com.intellij.openapi.editor.Editor; diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/DebugInfoAnnotator.java b/idea/src/org/jetbrains/jet/plugin/highlighter/DebugInfoAnnotator.java index 9c873a73df0..0421c720cc7 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/DebugInfoAnnotator.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/DebugInfoAnnotator.java @@ -29,7 +29,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetNodeTypes; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; -import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic; +import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.types.ErrorUtils; @@ -72,8 +72,8 @@ public class DebugInfoAnnotator implements Annotator { final Set unresolvedReferences = Sets.newHashSet(); for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { - if (diagnostic instanceof UnresolvedReferenceDiagnostic) { - unresolvedReferences.add(((UnresolvedReferenceDiagnostic) diagnostic).getPsiElement()); + if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) { + unresolvedReferences.add((JetReferenceExpression)diagnostic.getPsiElement()); } } diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/IdeErrorMessages.java b/idea/src/org/jetbrains/jet/plugin/highlighter/IdeErrorMessages.java new file mode 100644 index 00000000000..ea0c7300bdb --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/IdeErrorMessages.java @@ -0,0 +1,219 @@ +/* + * 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.plugin.highlighter; + +import com.intellij.psi.PsiElement; +import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters1; +import org.jetbrains.jet.lang.diagnostics.Errors; +import org.jetbrains.jet.lang.diagnostics.rendering.*; +import org.jetbrains.jet.lang.psi.JetValueArgument; +import org.jetbrains.jet.lang.psi.ValueArgument; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.FqNameUnsafe; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; +import org.jetbrains.jet.lang.resolve.calls.ResolvedValueArgument; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.resolve.DescriptorRenderer; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import static org.jetbrains.jet.lang.diagnostics.Errors.*; +import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.*; + +/** + * @see DefaultErrorMessages + * + * @author Evgeny Gerashchenko + * @since 4/13/12 + */ +public class IdeErrorMessages { + public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap(); + public static final DiagnosticRenderer RENDERER = new DispatchingDiagnosticRenderer(MAP, DefaultErrorMessages.MAP); + + private static final Renderer>> HTML_AMBIGUOUS_CALLS = + new Renderer>>() { + @NotNull + @Override + public String render(@NotNull Collection> calls) { + StringBuilder stringBuilder = new StringBuilder(""); + for (ResolvedCall call : calls) { + stringBuilder.append("
  • "); + stringBuilder.append(DescriptorRenderer.HTML.render(call.getResultingDescriptor())).append("\n"); + stringBuilder.append("
    • "); + } + return stringBuilder.toString(); + } + }; + + static { + MAP.put(TYPE_MISMATCH, "Type mismatch.
    Required:{0}
    Found:{1}
    ", RENDER_TYPE, RENDER_TYPE); + + MAP.put(ASSIGN_OPERATOR_AMBIGUITY, "Assignment operators ambiguity. All these functions match.
      {0}
    ", + HTML_AMBIGUOUS_CALLS); + + MAP.put(WRONG_SETTER_PARAMETER_TYPE, "Setter parameter type must be equal to the type of the property." + + "" + + "
    Expected:{0}
    Found:{1}
    ", RENDER_TYPE, RENDER_TYPE); + MAP.put(WRONG_GETTER_RETURN_TYPE, "Getter return type must be equal to the type of the property." + + "" + + "
    Expected:{0}
    Found:{1}
    ", RENDER_TYPE, RENDER_TYPE); + + MAP.put(ITERATOR_AMBIGUITY, "Method ''iterator()'' is ambiguous for this expression.
      {0}
    ", HTML_AMBIGUOUS_CALLS); + + MAP.put(UPPER_BOUND_VIOLATED, "Type argument is not within its bounds." + + "" + + "
    Expected:{0}
    Found:{1}
    ", RENDER_TYPE, RENDER_TYPE); + + MAP.put(TYPE_MISMATCH_IN_FOR_LOOP, "Loop parameter type mismatch." + + "" + + "
    Iterated values:{0}
    Parameter:{1}
    ", RENDER_TYPE, RENDER_TYPE); + + MAP.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, "Return type is ''{0}'', which is not a subtype of overridden
    " + + "{1}", + new Renderer() { + @NotNull + @Override + public String render(@NotNull CallableMemberDescriptor object) { + return DescriptorRenderer.TEXT.renderType(object.getReturnType()); + } + }, DescriptorRenderer.HTML); + + MAP.put(VAR_OVERRIDDEN_BY_VAL, "Val-property cannot override var-property
    " + + "{1}", DescriptorRenderer.HTML, DescriptorRenderer.HTML); + + MAP.put(ABSTRACT_MEMBER_NOT_IMPLEMENTED, "{0} must be declared abstract or implement abstract member
    " + + "{1}", RENDER_CLASS_OR_OBJECT, + DescriptorRenderer.HTML); + + MAP.put(MANY_IMPL_MEMBER_NOT_IMPLEMENTED, "{0} must override {1}
    because it inherits many implementations of it", + RENDER_CLASS_OR_OBJECT, DescriptorRenderer.HTML); + MAP.put(CONFLICTING_OVERLOADS, "{1}
    is already defined in ''{0}''", DescriptorRenderer.HTML, TO_STRING); + + MAP.put(RESULT_TYPE_MISMATCH, "Function return type mismatch." + + "" + + "
    Expected:{1}
    Found:{2}
    ", TO_STRING, RENDER_TYPE, RENDER_TYPE); + + MAP.put(OVERLOAD_RESOLUTION_AMBIGUITY, "Overload resolution ambiguity. All these functions match.
      {0}
    ", HTML_AMBIGUOUS_CALLS); + MAP.put(NONE_APPLICABLE, "None of the following functions can be called with the arguments supplied.
      {0}
    ", + new NoneApplicableCallsRenderer()); + + MAP.setImmutable(); + } + + private IdeErrorMessages() { + } + + private static class NoneApplicableCallsRenderer implements Renderer>> { + @Nullable + private static ValueParameterDescriptor findParameterByArgumentExpression( + ResolvedCall call, + JetValueArgument argument) { + for (Map.Entry entry : call.getValueArguments().entrySet()) { + for (ValueArgument va : entry.getValue().getArguments()) { + if (va == argument) { + return entry.getKey(); + } + } + } + return null; + } + + private static Set getParametersToHighlight(ResolvedCall call) { + Set parameters = new HashSet(); + if (call instanceof ResolvedCallImpl) { + Collection diagnostics = ((ResolvedCallImpl)call).getTrace().getBindingContext().getDiagnostics(); + for (Diagnostic diagnostic : diagnostics) { + if (diagnostic.getFactory() == Errors.TOO_MANY_ARGUMENTS) { + parameters.add(null); + } else if (diagnostic.getFactory() == Errors.NO_VALUE_FOR_PARAMETER) { + ValueParameterDescriptor parameter = + ((DiagnosticWithParameters1)diagnostic).getA(); + parameters.add(parameter); + } else { + JetValueArgument argument = PsiTreeUtil.getParentOfType(diagnostic.getPsiElement(), JetValueArgument.class, false); + if (argument != null) { + ValueParameterDescriptor parameter = findParameterByArgumentExpression(call, argument); + if (parameter != null) { + parameters.add(parameter); + } + } + } + } + } + return parameters; + } + + @NotNull + @Override + public String render(@NotNull Collection> calls) { + String RED_TEMPLATE = "%s"; + + StringBuilder stringBuilder = new StringBuilder(""); + for (ResolvedCall call : calls) { + stringBuilder.append("
  • "); + CallableDescriptor funDescriptor = call.getResultingDescriptor(); + Set parametersToHighlight = getParametersToHighlight(call); + + stringBuilder.append(funDescriptor.getName()).append("("); + boolean first = true; + DescriptorRenderer htmlRend = DescriptorRenderer.HTML; + for (ValueParameterDescriptor parameter : funDescriptor.getValueParameters()) { + if (!first) { + stringBuilder.append(", "); + } + JetType type = parameter.getType(); + JetType varargElementType = parameter.getVarargElementType(); + if (varargElementType != null) { + type = varargElementType; + } + String paramString = (varargElementType != null ? "vararg " : "") + htmlRend.renderType(type); + if (parameter.hasDefaultValue()) { + paramString += " = ..."; + } + if (parametersToHighlight.contains(parameter)) { + paramString = String.format(RED_TEMPLATE, paramString); + } + stringBuilder.append(paramString); + + first = false; + } + stringBuilder.append(parametersToHighlight.contains(null) ? String.format(RED_TEMPLATE, ")") : ")"); + stringBuilder.append(" ").append(htmlRend.renderMessage("defined in")).append(" "); + DeclarationDescriptor containingDeclaration = funDescriptor.getContainingDeclaration(); + if (containingDeclaration != null) { + FqNameUnsafe fqName = DescriptorUtils.getFQName(containingDeclaration); + stringBuilder.append(FqName.ROOT.toUnsafe().equals(fqName) ? "root package" : fqName.getFqName()); + } + stringBuilder.append("
    • "); + } + return stringBuilder.toString(); + } + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java index bd9577948c6..2767ea51553 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java @@ -35,6 +35,7 @@ import com.intellij.util.PsiNavigateUtil; import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.Modality; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.psi.JetProperty; @@ -91,12 +92,12 @@ public class JetLineMarkerProvider implements LineMarkerProvider { builder.append(DescriptorRenderer.HTML.render(descriptor)); int overrideCount = overriddenMembers.size(); if (overrideCount >= 1) { - builder.append(" ").append(implementsOrOverrides).append(" "); + builder.append("\n").append(implementsOrOverrides).append("\n"); builder.append(DescriptorRenderer.HTML.render(overriddenMembers.iterator().next())); } if (overrideCount > 1) { int count = overrideCount - 1; - builder.append(" and ").append(count).append(" other ").append(memberKind); + builder.append("\nand ").append(count).append(" other ").append(memberKind); if (count > 1) { builder.append("s"); } @@ -132,7 +133,10 @@ public class JetLineMarkerProvider implements LineMarkerProvider { public String getElementText(PsiElement element) { if (element instanceof JetNamedFunction) { JetNamedFunction function = (JetNamedFunction) element; - return DescriptorRenderer.HTML.render(bindingContext.get(BindingContext.FUNCTION, function)); + SimpleFunctionDescriptor fd = + bindingContext.get(BindingContext.FUNCTION, function); + assert fd != null; + return DescriptorRenderer.HTML.render(fd); } return super.getElementText(element); } diff --git a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java index 3fcbddeae37..c11debd4cdd 100644 --- a/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java @@ -30,10 +30,12 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.MultiRangeReference; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiReference; +import com.intellij.xml.util.XmlStringUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; import org.jetbrains.jet.lang.diagnostics.*; +import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -145,16 +147,14 @@ public class JetPsiChecker implements Annotator { if (diagnostic.getFactory() == Errors.UNRESOLVED_IDE_TEMPLATE) { return; } - if (diagnostic instanceof UnresolvedReferenceDiagnostic) { - UnresolvedReferenceDiagnostic unresolvedReferenceDiagnostic = (UnresolvedReferenceDiagnostic)diagnostic; - JetReferenceExpression referenceExpression = unresolvedReferenceDiagnostic.getPsiElement(); + if (diagnostic.getFactory() instanceof UnresolvedReferenceDiagnosticFactory) { + JetReferenceExpression referenceExpression = (JetReferenceExpression)diagnostic.getPsiElement(); PsiReference reference = referenceExpression.getReference(); if (reference instanceof MultiRangeReference) { MultiRangeReference mrr = (MultiRangeReference)reference; for (TextRange range : mrr.getRanges()) { - Annotation annotation = holder.createErrorAnnotation( - range.shiftRight(referenceExpression.getTextOffset()), - diagnostic.getMessage()); + Annotation annotation = holder.createErrorAnnotation(range.shiftRight(referenceExpression.getTextOffset()), getDefaultMessage(diagnostic)); + annotation.setTooltip(getMessage(diagnostic)); registerQuickFix(annotation, diagnostic); @@ -163,7 +163,8 @@ public class JetPsiChecker implements Annotator { } else { for (TextRange textRange : textRanges) { - Annotation annotation = holder.createErrorAnnotation(textRange, diagnostic.getMessage()); + Annotation annotation = holder.createErrorAnnotation(textRange, getDefaultMessage(diagnostic)); + annotation.setTooltip(getMessage(diagnostic)); registerQuickFix(annotation, diagnostic); annotation.setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); } @@ -174,22 +175,22 @@ public class JetPsiChecker implements Annotator { if (diagnostic.getFactory() == Errors.ILLEGAL_ESCAPE_SEQUENCE) { for (TextRange textRange : diagnostic.getTextRanges()) { - Annotation annotation = holder.createErrorAnnotation(textRange, getMessage(diagnostic)); + Annotation annotation = holder.createErrorAnnotation(textRange, getDefaultMessage(diagnostic)); + annotation.setTooltip(getMessage(diagnostic)); annotation.setTextAttributes(JetHighlightingColors.INVALID_STRING_ESCAPE); - //annotation.setEnforcedTextAttributes(TextAttributes.merge(JetHighlightingColors.INVALID_STRING_ESCAPE.getDefaultAttributes(), annotation.getTextAttributes().getDefaultAttributes())); } return; } - if (diagnostic instanceof RedeclarationDiagnostic) { - RedeclarationDiagnostic redeclarationDiagnostic = (RedeclarationDiagnostic)diagnostic; - registerQuickFix(markRedeclaration(redeclarations, redeclarationDiagnostic, holder), diagnostic); + if (diagnostic.getFactory() instanceof RedeclarationDiagnosticFactory) { + registerQuickFix(markRedeclaration(redeclarations, diagnostic, holder), diagnostic); return; } // Generic annotation for (TextRange textRange : textRanges) { - Annotation errorAnnotation = holder.createErrorAnnotation(textRange, getMessage(diagnostic)); + Annotation errorAnnotation = holder.createErrorAnnotation(textRange, getDefaultMessage(diagnostic)); + errorAnnotation.setTooltip(getMessage(diagnostic)); registerQuickFix(errorAnnotation, diagnostic); if (diagnostic.getFactory() == Errors.INVISIBLE_REFERENCE) { @@ -199,7 +200,8 @@ public class JetPsiChecker implements Annotator { } else if (diagnostic.getSeverity() == Severity.WARNING) { for (TextRange textRange : textRanges) { - Annotation annotation = holder.createWarningAnnotation(textRange, getMessage(diagnostic)); + Annotation annotation = holder.createWarningAnnotation(textRange, getDefaultMessage(diagnostic)); + annotation.setTooltip(getMessage(diagnostic)); registerQuickFix(annotation, diagnostic); if (diagnostic.getFactory() instanceof UnusedElementDiagnosticFactory) { @@ -239,19 +241,39 @@ public class JetPsiChecker implements Annotator { @NotNull private static String getMessage(@NotNull Diagnostic diagnostic) { + String message = IdeErrorMessages.RENDERER.render(diagnostic); if (ApplicationManager.getApplication().isInternal() || ApplicationManager.getApplication().isUnitTestMode()) { - return "[" + diagnostic.getFactory().getName() + "] " + diagnostic.getMessage(); + String factoryName = diagnostic.getFactory().getName(); + if (message.startsWith("")) { + message = String.format("[%s] %s", factoryName, message.substring("".length())); + } else { + message = String.format("[%s] %s", factoryName, message); + } } - return diagnostic.getMessage(); + if (!message.startsWith("")) { + message = "" + XmlStringUtil.escapeString(message) + ""; + } + return message; + } + + @NotNull + private static String getDefaultMessage(@NotNull Diagnostic diagnostic) { + String message = DefaultErrorMessages.RENDERER.render(diagnostic); + if (ApplicationManager.getApplication().isInternal() || ApplicationManager.getApplication().isUnitTestMode()) { + return String.format("[%s] %s", diagnostic.getFactory().getName(), message); + } + return message; } @Nullable private static Annotation markRedeclaration(@NotNull Set redeclarations, - @NotNull RedeclarationDiagnostic diagnostic, + @NotNull Diagnostic redeclarationDiagnostic, @NotNull AnnotationHolder holder) { - if (!redeclarations.add(diagnostic.getPsiElement())) return null; - List textRanges = diagnostic.getTextRanges(); + if (!redeclarations.add(redeclarationDiagnostic.getPsiElement())) return null; + List textRanges = redeclarationDiagnostic.getTextRanges(); if (textRanges.isEmpty()) return null; - return holder.createErrorAnnotation(textRanges.get(0), getMessage(diagnostic)); + Annotation annotation = holder.createErrorAnnotation(textRanges.get(0), ""); + annotation.setTooltip(getMessage(redeclarationDiagnostic)); + return annotation; } } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java new file mode 100644 index 00000000000..f10680dddf5 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java @@ -0,0 +1,88 @@ +/* + * 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.plugin.intentions; + +import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction; +import com.intellij.openapi.editor.Editor; +import com.intellij.openapi.project.Project; +import com.intellij.psi.PsiElement; +import com.intellij.psi.impl.source.tree.LeafPsiElement; +import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetProperty; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.ErrorUtils; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lexer.JetTokens; +import org.jetbrains.jet.plugin.JetBundle; +import org.jetbrains.jet.plugin.project.AnalyzeSingleFileUtil; +import org.jetbrains.jet.plugin.refactoring.introduceVariable.JetChangePropertyActions; + +/** + * @author Evgeny Gerashchenko + * @since 4/20/12 + */ +public class SpecifyTypeExplicitlyAction extends PsiElementBaseIntentionAction { + private JetType targetType; + + @NotNull + @Override + public String getText() { + return targetType == null ? JetBundle.message("specify.type.explicitly.remove.action.name") : JetBundle.message("specify.type.explicitly.add.action.name"); + } + + @NotNull + @Override + public String getFamilyName() { + return JetBundle.message("specify.type.explicitly.action.family.name"); + } + + @Override + public void invoke(@NotNull Project project, Editor editor, @NotNull PsiElement element) { + JetProperty property = (JetProperty)element.getParent(); + if (targetType == null) { + JetChangePropertyActions.removeTypeAnnotation(project, property); + } else { + JetChangePropertyActions.addTypeAnnotation(project, property, targetType); + } + } + + @Override + public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) { + if (!(element.getParent() instanceof JetProperty) || PsiTreeUtil.isAncestor(((JetProperty)element.getParent()).getInitializer(), element, false)) { + return false; + } + + JetProperty property = (JetProperty)element.getParent(); + boolean hasTypeSpecified = property.getPropertyTypeRef() != null; + if (hasTypeSpecified) { + targetType = null; + } else { + BindingContext bindingContext = AnalyzeSingleFileUtil.getContextForSingleFile((JetFile)element.getContainingFile()); + DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property); + assert descriptor instanceof VariableDescriptor; + targetType = ((VariableDescriptor)descriptor).getType(); + if (ErrorUtils.isErrorType(targetType)) { + return false; + } + } + return true; + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfiguration.java b/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfiguration.java index 88e0730ee9a..16154253090 100644 --- a/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfiguration.java +++ b/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfiguration.java @@ -38,6 +38,7 @@ import org.jetbrains.annotations.NotNull; /** * @author Pavel Talanov */ +@SuppressWarnings("deprecation") public final class K2JSRunConfiguration extends RunConfigurationBase implements RunConfigurationWithSuppressedDefaultRunAction { @@ -78,14 +79,17 @@ public final class K2JSRunConfiguration extends RunConfigurationBase @Override public ExecutionResult execute(Executor executor, @NotNull ProgramRunner runner) throws ExecutionException { return new ExecutionResult() { + @Override public ExecutionConsole getExecutionConsole() { return null; } + @Override public AnAction[] getActions() { return AnAction.EMPTY_ARRAY; } + @Override public ProcessHandler getProcessHandler() { return null; } diff --git a/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfigurationEditor.java b/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfigurationEditor.java index ebe4e3f1bbf..0a63582a1ac 100644 --- a/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfigurationEditor.java +++ b/idea/src/org/jetbrains/jet/plugin/k2jsrun/K2JSRunConfigurationEditor.java @@ -26,11 +26,18 @@ import com.intellij.openapi.options.SettingsEditor; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.ProjectRootManager; import com.intellij.openapi.ui.TextFieldWithBrowseButton; +import com.jgoodies.looks.Fonts; import org.jetbrains.annotations.NotNull; import javax.swing.*; +import javax.swing.event.DocumentEvent; +import javax.swing.event.DocumentListener; +import java.awt.*; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; import java.awt.event.ItemEvent; import java.awt.event.ItemListener; +import java.io.File; import static com.intellij.openapi.util.io.FileUtil.toSystemIndependentName; @@ -88,6 +95,32 @@ public final class K2JSRunConfigurationEditor extends SettingsEditor files, @NotNull Predicate filesToAnalyzeCompletely, @NotNull JetControlFlowDataTraceFactory flowDataTraceFactory) { - BindingContext context = AnalyzerFacadeForJS.analyzeFiles(files, new IDEAConfig(project)); + BindingContext context = AnalyzerFacadeForJS.analyzeFiles(files, filesToAnalyzeCompletely, new IDEAConfig(project)); return AnalyzeExhaust.success(context, JetStandardLibrary.getInstance()); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddReturnTypeFix.java index 006cb2c3878..6a55bbfd471 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddReturnTypeFix.java @@ -68,7 +68,7 @@ public class AddReturnTypeFix extends JetIntentionAction { assert element instanceof JetFunction; newElement = addFunctionType(project, (JetFunction) element, type); } - ImportInsertHelper.addImportDirectiveIfNeeded(type, (JetFile) file); + ImportInsertHelper.addImportDirectivesIfNeeded(type, (JetFile)file); element.replace(newElement); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java index 42dc1a79121..9dc612eda86 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java @@ -17,22 +17,21 @@ package org.jetbrains.jet.plugin.quickfix; import com.intellij.psi.PsiElement; -import com.intellij.usages.impl.rules.NonCodeUsageGroupingRule; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.DefaultModuleConfiguration; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetPsiUtil; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.FqName; -import org.jetbrains.jet.lang.resolve.ImportPath; +import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.plugin.JetPluginUtil; import org.jetbrains.jet.util.QualifiedNamesUtil; @@ -53,7 +52,7 @@ public class ImportInsertHelper { * @param type type to import * @param file file where import directive should be added */ - public static void addImportDirectiveIfNeeded(@NotNull JetType type, @NotNull JetFile file) { + public static void addImportDirectivesIfNeeded(@NotNull JetType type, @NotNull JetFile file) { if (JetPluginUtil.checkTypeIsStandard(type, file.getProject()) || ErrorUtils.isErrorType(type)) { return; } @@ -62,7 +61,9 @@ public class ImportInsertHelper { if (element != null && element.getContainingFile() == file) { //declaration is in the same file, so no import is needed return; } - addImportDirective(JetPluginUtil.computeTypeFullName(type), file); + for (ClassDescriptor clazz : TypeUtils.getAllClassDescriptors(type)) { + addImportDirective(DescriptorUtils.getFQName(getTopLevelClass(clazz)).toSafe(), file); + } } /** @@ -155,4 +156,15 @@ public class ImportInsertHelper { return true; } + + private static ClassDescriptor getTopLevelClass(ClassDescriptor classDescriptor) { + while (true) { + DeclarationDescriptor parent = classDescriptor.getContainingDeclaration(); + if (parent instanceof ClassDescriptor) { + classDescriptor = (ClassDescriptor) parent; + } else { + return classDescriptor; + } + } + } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java index 886ea3ea8ed..f67c6452cb3 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/RemovePartsFromPropertyFix.java @@ -119,7 +119,7 @@ public class RemovePartsFromPropertyFix extends JetIntentionAction } } if (needImport) { - ImportInsertHelper.addImportDirectiveIfNeeded(type, (JetFile) file); + ImportInsertHelper.addImportDirectivesIfNeeded(type, (JetFile)file); } element.replace(newElement); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java index 79306959dda..efb8d885e06 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java @@ -20,7 +20,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Ref; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.compiler.TipsManager; +import org.jetbrains.jet.cli.jvm.compiler.TipsManager; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetFile; diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetChangePropertyActions.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetChangePropertyActions.java index 8cd70130ea4..eef765ba774 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetChangePropertyActions.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduceVariable/JetChangePropertyActions.java @@ -5,10 +5,13 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiWhiteSpace; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetTypeReference; import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper; +import org.jetbrains.jet.resolve.DescriptorRenderer; /** * User: Alefas @@ -35,13 +38,14 @@ public class JetChangePropertyActions { if (anchor == null) return; anchor = anchor.getNextSibling(); if (anchor == null || !(anchor instanceof PsiWhiteSpace)) return; - JetTypeReference typeReference = JetPsiFactory.createType(project, exprType.toString()); + JetTypeReference typeReference = JetPsiFactory.createType(project, DescriptorRenderer.TEXT.renderTypeWithShortNames(exprType)); ASTNode colon = JetPsiFactory.createColonNode(project); ASTNode anchorNode = anchor.getNode().getTreeNext(); property.getNode().addChild(colon, anchorNode); property.getNode().addChild(JetPsiFactory.createWhiteSpace(project).getNode(), anchorNode); property.getNode().addChild(typeReference.getNode(), anchorNode); property.getNode().addChild(JetPsiFactory.createWhiteSpace(project).getNode(), anchorNode); + ImportInsertHelper.addImportDirectivesIfNeeded(exprType, (JetFile)property.getContainingFile()); anchor.delete(); } diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java index 0b583f8684e..6be592e32e9 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java +++ b/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java @@ -20,7 +20,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.psi.PsiElement; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.compiler.TipsManager; +import org.jetbrains.jet.cli.jvm.compiler.TipsManager; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; diff --git a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationType.java b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationType.java index e698deed70c..8d08fb898b5 100644 --- a/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationType.java +++ b/idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationType.java @@ -19,7 +19,7 @@ package org.jetbrains.jet.plugin.run; import com.intellij.execution.configurations.*; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.plugin.JetFileType; +import org.jetbrains.jet.plugin.JetIcons; /** * @author yole @@ -30,7 +30,7 @@ public class JetRunConfigurationType extends ConfigurationTypeBase { } public JetRunConfigurationType() { - super("JetRunConfigurationType", "Kotlin", "Kotlin", JetFileType.INSTANCE.getIcon()); + super("JetRunConfigurationType", "Kotlin", "Kotlin", JetIcons.LAUNCH); addFactory(new JetRunConfigurationFactory(this)); } diff --git a/idea/testData/checker/infos/Autocasts.jet b/idea/testData/checker/infos/Autocasts.jet index 9bd17ee710a..75c9df003e7 100644 --- a/idea/testData/checker/infos/Autocasts.jet +++ b/idea/testData/checker/infos/Autocasts.jet @@ -8,19 +8,19 @@ class B() : A() { fun f9(a : A?) { a?.foo() - a?.bar() + a?.bar() if (a is B) { a.bar() a.foo() } a?.foo() - a?.bar() + a?.bar() if (!(a is B)) { - a?.bar() + a?.bar() a?.foo() } if (!(a is B) || a.bar() == #()) { - a?.bar() + a?.bar() } if (!(a is B)) { return; @@ -55,7 +55,7 @@ fun f11(a : A?) { is B -> a.bar() is A -> a.foo() is Any -> a.foo() - is Any? -> a.bar() + is Any? -> a.bar() else -> a?.foo() } } @@ -65,15 +65,15 @@ fun f12(a : A?) { is B -> a.bar() is A -> a.foo() is Any -> a.foo(); - is Any? -> a.bar() - is val c : B -> c.foo() + is Any? -> a.bar() + is val c : B -> c.foo() is val c is C -> c.bar() is val c is C -> a.bar() else -> a?.foo() } if (a is val b) { - a?.bar() + a?.bar() b?.foo() } if (a is val b is B) { @@ -90,17 +90,17 @@ fun f13(a : A?) { } else { a?.foo() - c.bar() + c.bar() } a?.foo() if (!(a is val c is B)) { a?.foo() - c.bar() + c.bar() } else { a.foo() - c.bar() + c.bar() } a?.foo() @@ -110,16 +110,16 @@ fun f13(a : A?) { } else { a?.foo() - c.bar() + c.bar() } if (!(a is val c is B) || !(a is val x is C)) { - x - c + x + c } else { - x - c + x + c } if (!(a is val c is B) || !(a is val c is C)) { @@ -127,21 +127,21 @@ fun f13(a : A?) { if (!(a is val c is B)) return a.bar() - c.foo() - c.bar() + c.foo() + c.bar() } fun f14(a : A?) { while (!(a is val c is B)) { } a.bar() - c.bar() + c.bar() } fun f15(a : A?) { do { } while (!(a is val c is B)) a.bar() - c.bar() + c.bar() } fun getStringLength(obj : Any) : Char? { @@ -217,37 +217,37 @@ fun declarationInsidePattern(x: #(Any, Any)): String = when(x) { is #(val a is S fun mergeAutocasts(a: Any?) { if (a is String || a is Int) { - a.compareTo("") + a.compareTo("") a.toString() } if (a is Int || a is String) { - a.compareTo("") + a.compareTo("") } when (a) { - is String, is Any -> a.compareTo("") + is String, is Any -> a.compareTo("") } if (a is String && a is Any) { val i: Int = a.compareTo("") } if (a is String && a.compareTo("") == 0) {} - if (a is String || a.compareTo("") == 0) {} + if (a is String || a.compareTo("") == 0) {} } //mutability fun f(): String { var a: Any = 11 if (a is String) { - val i: String = a - a.compareTo("f") - val f: Function0 = { a } - return a + val i: String = a + a.compareTo("f") + val f: Function0 = { a } + return a } return "" } fun foo(var a: Any): Int { if (a is Int) { - return a + return a } return 1 } diff --git a/idea/testData/codeInsight/overrideImplement/functionWithTypeParameters.kt b/idea/testData/codeInsight/overrideImplement/functionWithTypeParameters.kt new file mode 100644 index 00000000000..699f1b7034a --- /dev/null +++ b/idea/testData/codeInsight/overrideImplement/functionWithTypeParameters.kt @@ -0,0 +1,7 @@ +trait Trait { + fun > foo() where B : Cloneable, B : Comparable; +} + +class TraitImpl : Trait { + +} \ No newline at end of file diff --git a/idea/testData/codeInsight/overrideImplement/functionWithTypeParameters.kt.after b/idea/testData/codeInsight/overrideImplement/functionWithTypeParameters.kt.after new file mode 100644 index 00000000000..eaf92a65bb1 --- /dev/null +++ b/idea/testData/codeInsight/overrideImplement/functionWithTypeParameters.kt.after @@ -0,0 +1,13 @@ +import java.util.Map + +trait Trait { + fun > foo() where B : Cloneable, B : Comparable; +} + +class TraitImpl : Trait { + + override fun > foo() + where B : Cloneable, B : Comparable { + throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/idea/testData/libraries/decompiled/namespace.kt b/idea/testData/libraries/decompiled/namespace.kt index 100819a0647..7357f1b34c7 100644 --- a/idea/testData/libraries/decompiled/namespace.kt +++ b/idea/testData/libraries/decompiled/namespace.kt @@ -15,12 +15,12 @@ package testData.libraries [public final fun func() : Unit { /* compiled code */ }] -[public final fun func(val a : jet.Int, val b : jet.Int) : Unit { /* compiled code */ }] +[public final fun func(a : jet.Int, b : jet.Int) : Unit { /* compiled code */ }] -[public final fun func(val a : jet.Int, val b : jet.String = /* compiled code */) : Unit { /* compiled code */ }] +[public final fun func(a : jet.Int, b : jet.String = /* compiled code */) : Unit { /* compiled code */ }] -[public final fun func(val str : jet.String) : Unit { /* compiled code */ }] +[public final fun func(str : jet.String) : Unit { /* compiled code */ }] -[public final fun main(val args : jet.Array) : Unit { /* compiled code */ }] +[public final fun main(args : jet.Array) : Unit { /* compiled code */ }] -[public final fun T.filter(val predicate : (T) -> jet.Boolean) : T? { /* compiled code */ }] +[public final fun T.filter(predicate : (T) -> jet.Boolean) : T? { /* compiled code */ }] diff --git a/idea/testData/wordSelection/TypeArguments.1.kt b/idea/testData/wordSelection/TypeArguments.1.kt new file mode 100644 index 00000000000..c2720afa24f --- /dev/null +++ b/idea/testData/wordSelection/TypeArguments.1.kt @@ -0,0 +1,3 @@ +fun foo() { + foo<Int, B>() +} diff --git a/idea/testData/wordSelection/TypeArguments.kt b/idea/testData/wordSelection/TypeArguments.kt new file mode 100644 index 00000000000..0585d99d48b --- /dev/null +++ b/idea/testData/wordSelection/TypeArguments.kt @@ -0,0 +1,3 @@ +fun foo() { + foo<Int, B>() +} diff --git a/idea/testData/wordSelection/TypeParameters.1.kt b/idea/testData/wordSelection/TypeParameters.1.kt new file mode 100644 index 00000000000..332865cfb5a --- /dev/null +++ b/idea/testData/wordSelection/TypeParameters.1.kt @@ -0,0 +1,2 @@ +fun <A, B> foo() { +} diff --git a/idea/testData/wordSelection/TypeParameters.kt b/idea/testData/wordSelection/TypeParameters.kt new file mode 100644 index 00000000000..d8509f74fdc --- /dev/null +++ b/idea/testData/wordSelection/TypeParameters.kt @@ -0,0 +1,2 @@ +fun B> foo() { +} diff --git a/idea/testData/wordSelection/ValueArguments.1.kt b/idea/testData/wordSelection/ValueArguments.1.kt new file mode 100644 index 00000000000..0078192e4dc --- /dev/null +++ b/idea/testData/wordSelection/ValueArguments.1.kt @@ -0,0 +1,3 @@ +fun foo() { + foo(1, 2) +} diff --git a/idea/testData/wordSelection/ValueArguments.kt b/idea/testData/wordSelection/ValueArguments.kt new file mode 100644 index 00000000000..54dee47384a --- /dev/null +++ b/idea/testData/wordSelection/ValueArguments.kt @@ -0,0 +1,3 @@ +fun foo() { + foo(1, 2) +} diff --git a/idea/testData/wordSelection/ValueParameters.1.kt b/idea/testData/wordSelection/ValueParameters.1.kt new file mode 100644 index 00000000000..df0a9e6bb58 --- /dev/null +++ b/idea/testData/wordSelection/ValueParameters.1.kt @@ -0,0 +1,2 @@ +fun foo(a : Array, b : Int) { +} diff --git a/idea/testData/wordSelection/ValueParameters.kt b/idea/testData/wordSelection/ValueParameters.kt new file mode 100644 index 00000000000..1105f741877 --- /dev/null +++ b/idea/testData/wordSelection/ValueParameters.kt @@ -0,0 +1,2 @@ +fun foo(a : Array, b : Int) { +} diff --git a/idea/tests/org/jetbrains/jet/plugin/WordSelectionTest.java b/idea/tests/org/jetbrains/jet/plugin/WordSelectionTest.java index 21c82df53b1..82c6031392e 100644 --- a/idea/tests/org/jetbrains/jet/plugin/WordSelectionTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/WordSelectionTest.java @@ -35,6 +35,22 @@ public class WordSelectionTest extends LightCodeInsightFixtureTestCase { doTest(6); } + public void testTypeArguments() { + doTest(1); + } + + public void testValueArguments() { + doTest(1); + } + + public void testTypeParameters() { + doTest(1); + } + + public void testValueParameters() { + doTest(1); + } + private void doTest(int howMany) { String testName = getTestName(false); String[] afterFiles = new String[howMany]; diff --git a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java index eb35f51df8f..fadfbc34b22 100644 --- a/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/codeInsight/OverrideImplementTest.java @@ -58,6 +58,10 @@ public class OverrideImplementTest extends LightCodeInsightFixtureTestCase { doImplementFileTest(); } + public void testFunctionWithTypeParameters() { + doImplementFileTest(); + } + public void testJavaInterfaceMethod() { doImplementDirectoryTest(); } diff --git a/idea/tests/org/jetbrains/jet/plugin/libraries/AbstractLibrariesTest.java b/idea/tests/org/jetbrains/jet/plugin/libraries/AbstractLibrariesTest.java index d534e506ec2..86ebd521d91 100644 --- a/idea/tests/org/jetbrains/jet/plugin/libraries/AbstractLibrariesTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/libraries/AbstractLibrariesTest.java @@ -25,9 +25,11 @@ import com.intellij.openapi.vfs.LocalFileSystem; import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileVisitor; +import com.intellij.openapi.vfs.newvfs.NewVirtualFile; import com.intellij.testFramework.PlatformTestCase; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.common.ExitCode; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import org.jetbrains.jet.plugin.PluginTestCaseBase; import java.io.File; @@ -60,12 +62,15 @@ public abstract class AbstractLibrariesTest extends PlatformTestCase { }); librarySourceDir = LocalFileSystem.getInstance().findFileByPath(TEST_DATA_PATH + "/library"); assertNotNull(librarySourceDir); - KotlinCompiler.ExitCode compilerExec = - new KotlinCompiler().exec(System.out, "-src", librarySourceDir.getPath(), "-output", libraryIoDir.getAbsolutePath()); - assertEquals(KotlinCompiler.ExitCode.OK, compilerExec); + ExitCode compilerExec = + new K2JVMCompiler().exec(System.out, "-src", librarySourceDir.getPath(), "-output", libraryIoDir.getAbsolutePath()); + assertEquals(ExitCode.OK, compilerExec); libraryDir = LocalFileSystem.getInstance().findFileByIoFile(libraryIoDir); assertNotNull(libraryDir); + ((NewVirtualFile)libraryDir).markDirtyRecursively(); + libraryDir.refresh(false, true); + ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { diff --git a/idea/tests/org/jetbrains/jet/plugin/libraries/FakeJetPsiClassRegressionTest.java b/idea/tests/org/jetbrains/jet/plugin/libraries/LibraryNavigationRegressionTest.java similarity index 65% rename from idea/tests/org/jetbrains/jet/plugin/libraries/FakeJetPsiClassRegressionTest.java rename to idea/tests/org/jetbrains/jet/plugin/libraries/LibraryNavigationRegressionTest.java index da7bffa8e57..ac5873a882e 100644 --- a/idea/tests/org/jetbrains/jet/plugin/libraries/FakeJetPsiClassRegressionTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/libraries/LibraryNavigationRegressionTest.java @@ -16,7 +16,11 @@ package org.jetbrains.jet.plugin.libraries; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiElement; import com.intellij.psi.PsiReference; +import com.intellij.psi.search.GlobalSearchScope; import com.intellij.testFramework.LightProjectDescriptor; import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase; import org.jetbrains.annotations.NotNull; @@ -25,12 +29,13 @@ import org.jetbrains.jet.plugin.JetLanguage; import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor; /** - * This is a regression test against KT-1652 - * * @author Evgeny Gerashchenko * @since 3/27/12 */ -public class FakeJetPsiClassRegressionTest extends LightCodeInsightFixtureTestCase { +public class LibraryNavigationRegressionTest extends LightCodeInsightFixtureTestCase { + /** + * Regression test against KT-1652 + */ public void testRefToStdlib() { String text = "fun foo() { println() }"; myFixture.configureByText(JetFileType.INSTANCE, text); @@ -39,6 +44,9 @@ public class FakeJetPsiClassRegressionTest extends LightCodeInsightFixtureTestCa assertSame(JetLanguage.INSTANCE, ref.resolve().getNavigationElement().getLanguage()); } + /** + * Regression test against KT-1652 + */ public void testRefToJdk() { String text = "val x = java.util.HashMap().get(\"\")"; myFixture.configureByText(JetFileType.INSTANCE, text); @@ -47,6 +55,20 @@ public class FakeJetPsiClassRegressionTest extends LightCodeInsightFixtureTestCa ref.resolve().getNavigationElement(); } + /** + * Regression test against KT-1815 + */ + public void testRefToAltHeaders() { + String text = "fun foo(e : java.util.Map.Entry) { e.getKey(); }"; + myFixture.configureByText(JetFileType.INSTANCE, text); + PsiReference ref = myFixture.getFile().findReferenceAt(text.indexOf("getKey")); + PsiClass expectedClass = + JavaPsiFacade.getInstance(getProject()).findClass("java.util.Map.Entry", GlobalSearchScope.allScope(getProject())); + //noinspection ConstantConditions + PsiElement actualClass = ref.resolve().getNavigationElement().getParent(); + assertSame(expectedClass, actualClass); + } + @NotNull @Override protected LightProjectDescriptor getProjectDescriptor() { diff --git a/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java b/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java index ddf120ff89c..0faab5c25f8 100644 --- a/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java @@ -27,10 +27,12 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import javax.annotation.PostConstruct; +import javax.annotation.PreDestroy; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.PrintStream; +import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.lang.reflect.Modifier; @@ -106,6 +108,8 @@ public class DependencyInjectorGenerator { out.println(); generateConstructor(injectorClassName, out); out.println(); + generateDestroy(injectorClassName, out); + out.println(); generateGetters(out); // Needed to fix double-checked locking // out.println(); @@ -212,6 +216,7 @@ public class DependencyInjectorGenerator { break; } } + generateImportDirective(out, PreDestroy.class, injectorPackageName); } private void generateImportDirectives(PrintStream out, DiType type, String injectorPackageName) { @@ -233,10 +238,8 @@ public class DependencyInjectorGenerator { private void generateFields(PrintStream out) { for (Field field : fields) { - if (lazy || field.isPublic()) { - String _final = backsParameter.contains(field) ? "final " : ""; - out.println(" private " + _final + field.getType().getSimpleName() + " " + field.getName() + ";"); - } + String _final = backsParameter.contains(field) ? "final " : ""; + out.println(" private " + _final + field.getType().getSimpleName() + " " + field.getName() + ";"); } } @@ -272,10 +275,10 @@ public class DependencyInjectorGenerator { else { // Initialize fields for (Field field : fields) { - if (!backsParameter.contains(field) || field.isPublic()) { - String prefix = field.isPublic() ? "this." : field.getTypeName() + " "; + //if (!backsParameter.contains(field) || field.isPublic()) { + String prefix = "this."; out.println(indent + prefix + field.getName() + " = " + field.getInitialization() + ";"); - } + //} } out.println(); @@ -307,9 +310,17 @@ public class DependencyInjectorGenerator { } private static List getPostConstructMethods(Class clazz) { + return getInjectSpecialMethods(clazz, PostConstruct.class); + } + + private static List getPreDestroyMethods(Class clazz) { + return getInjectSpecialMethods(clazz, PreDestroy.class); + } + + private static List getInjectSpecialMethods(Class clazz, Class annotationClass) { List r = Lists.newArrayList(); for (Method method : clazz.getMethods()) { - if (method.getAnnotation(PostConstruct.class) != null) { + if (method.getAnnotation(annotationClass) != null) { if (method.getParameterTypes().length != 0) { throw new IllegalStateException("@PostConstruct method must have no arguments: " + method); } @@ -319,6 +330,22 @@ public class DependencyInjectorGenerator { return r; } + private void generateDestroy(@NotNull String injectorClassName, @NotNull PrintStream out) { + out.println(" @PreDestroy"); + out.println(" public void destroy() {"); + for (Field field : fields) { + // TODO: type of field may be different from type of object + List preDestroyMethods = getPreDestroyMethods(field.getType().getClazz()); + for (Method preDestroy : preDestroyMethods) { + out.println(" " + field.getName() + "." + preDestroy.getName() + "();"); + } + if (preDestroyMethods.size() > 0) { + out.println(); + } + } + out.println(" }"); + } + private void generateGetters(PrintStream out) { String indent0 = " "; String indent1 = indent0 + INDENT_STEP; diff --git a/js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java b/js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java index 27b72a70e82..17c0f30cc5a 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java @@ -21,7 +21,7 @@ import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; /** * @author Pavel Talanov diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 329d2c0b624..2eae6436681 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -49,6 +49,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForTopDownAnalyzerForJs { @@ -62,6 +63,22 @@ public class InjectorForTopDownAnalyzerForJs { private final Project project; private final TopDownAnalysisParameters topDownAnalysisParameters; private final ObservableBindingTrace observableBindingTrace; + private final ModuleDescriptor moduleDescriptor; + private final JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory; + private final ModuleConfiguration moduleConfiguration; + private DeclarationResolver declarationResolver; + private AnnotationResolver annotationResolver; + private CallResolver callResolver; + private ExpressionTypingServices expressionTypingServices; + private TypeResolver typeResolver; + private QualifiedExpressionResolver qualifiedExpressionResolver; + private OverloadingConflictResolver overloadingConflictResolver; + private ImportsResolver importsResolver; + private DelegationResolver delegationResolver; + private NamespaceFactoryImpl namespaceFactoryImpl; + private OverloadResolver overloadResolver; + private OverrideResolver overrideResolver; + private TypeHierarchyResolver typeHierarchyResolver; public InjectorForTopDownAnalyzerForJs( @NotNull Project project, @@ -80,19 +97,22 @@ public class InjectorForTopDownAnalyzerForJs { this.project = project; this.topDownAnalysisParameters = topDownAnalysisParameters; this.observableBindingTrace = observableBindingTrace; - DeclarationResolver declarationResolver = new DeclarationResolver(); - AnnotationResolver annotationResolver = new AnnotationResolver(); - CallResolver callResolver = new CallResolver(); - ExpressionTypingServices expressionTypingServices = new ExpressionTypingServices(); - TypeResolver typeResolver = new TypeResolver(); - QualifiedExpressionResolver qualifiedExpressionResolver = new QualifiedExpressionResolver(); - OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver(); - ImportsResolver importsResolver = new ImportsResolver(); - DelegationResolver delegationResolver = new DelegationResolver(); - NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); - OverloadResolver overloadResolver = new OverloadResolver(); - OverrideResolver overrideResolver = new OverrideResolver(); - TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver(); + this.moduleDescriptor = moduleDescriptor; + this.jetControlFlowDataTraceFactory = jetControlFlowDataTraceFactory; + this.moduleConfiguration = moduleConfiguration; + this.declarationResolver = new DeclarationResolver(); + this.annotationResolver = new AnnotationResolver(); + this.callResolver = new CallResolver(); + this.expressionTypingServices = new ExpressionTypingServices(); + this.typeResolver = new TypeResolver(); + this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); + this.overloadingConflictResolver = new OverloadingConflictResolver(); + this.importsResolver = new ImportsResolver(); + this.delegationResolver = new DelegationResolver(); + this.namespaceFactoryImpl = new NamespaceFactoryImpl(); + this.overloadResolver = new OverloadResolver(); + this.overrideResolver = new OverrideResolver(); + this.typeHierarchyResolver = new TypeHierarchyResolver(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setContext(topDownAnalysisContext); @@ -179,6 +199,10 @@ public class InjectorForTopDownAnalyzerForJs { } + @PreDestroy + public void destroy() { + } + public TopDownAnalyzer getTopDownAnalyzer() { return this.topDownAnalyzer; } diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index cb202551495..922995b6095 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -53,26 +53,27 @@ public final class AnalyzerFacadeForJS { @NotNull public static BindingContext analyzeFilesAndCheckErrors(@NotNull List files, - @NotNull Config config) { - BindingContext bindingContext = analyzeFiles(files, config); + @NotNull Config config) { + BindingContext bindingContext = analyzeFiles(files, Predicates.alwaysTrue(), config); checkForErrors(withJsLibAdded(files, config), bindingContext); return bindingContext; } @NotNull public static BindingContext analyzeFiles(@NotNull Collection files, - @NotNull Config config) { + Predicate filesToAnalyzeCompletely, @NotNull Config config) { Project project = config.getProject(); BindingTraceContext bindingTraceContext = new BindingTraceContext(); final ModuleDescriptor owner = new ModuleDescriptor(""); - TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - notLibFiles(config.getLibFiles()), false, false); + Predicate completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely); + + TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(completely, false, false); InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( - project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, - JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project)); + project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, + JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project)); injector.getTopDownAnalyzer().analyzeFiles(withJsLibAdded(files, config)); return bindingTraceContext.getBindingContext(); @@ -123,11 +124,11 @@ public final class AnalyzerFacadeForJS { final ModuleDescriptor owner = new ModuleDescriptor(""); TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( - Predicates.alwaysTrue(), false, false); + Predicates.alwaysTrue(), false, false); InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( - project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, - JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project)); + project, topDownAnalysisParameters, new ObservableBindingTrace(bindingTraceContext), owner, + JetControlFlowDataTraceFactory.EMPTY, JsConfiguration.jsLibConfiguration(project)); injector.getTopDownAnalyzer().analyzeFiles(Collections.singletonList(file)); return bindingTraceContext.getBindingContext(); @@ -156,9 +157,9 @@ public final class AnalyzerFacadeForJS { @Override public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, - @NotNull WritableScope namespaceMemberScope) { + @NotNull WritableScope namespaceMemberScope) { DefaultModuleConfiguration.createStandardConfiguration(project, true) - .extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope); + .extendNamespaceScope(trace, namespaceDescriptor, namespaceMemberScope); } } } diff --git a/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java b/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java index 0ef6e9b4f54..f137660accc 100644 --- a/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java @@ -19,6 +19,7 @@ package org.jetbrains.k2js.facade; import com.google.common.collect.Lists; import com.google.dart.compiler.backend.js.ast.JsProgram; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.io.FileUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -57,7 +58,9 @@ public final class K2JSTranslator { throw new RuntimeException("No file with main detected."); } String callToMain = generateCallToMain(fileWithMain, ""); - FileWriter writer = new FileWriter(new File(outputPath)); + File file = new File(outputPath); + FileUtil.createParentDirs(file); + FileWriter writer = new FileWriter(file); try { writer.write(programCode + callToMain); } diff --git a/libraries/stdlib/src/kotlin/Arrays.kt b/libraries/stdlib/src/kotlin/Arrays.kt index 74a8cd50b08..15f4e031e92 100644 --- a/libraries/stdlib/src/kotlin/Arrays.kt +++ b/libraries/stdlib/src/kotlin/Arrays.kt @@ -124,3 +124,30 @@ public inline fun Array.isEmpty() : Boolean = this.size == 0 /** Returns the array if its not null or else returns an empty array */ public inline fun Array?.orEmpty() : Array = if (this != null) this else array() + +public inline val BooleanArray.lastIndex : Int + get() = this.size - 1 + +public inline val ByteArray.lastIndex : Int + get() = this.size - 1 + +public inline val ShortArray.lastIndex : Int + get() = this.size - 1 + +public inline val IntArray.lastIndex : Int + get() = this.size - 1 + +public inline val LongArray.lastIndex : Int + get() = this.size - 1 + +public inline val FloatArray.lastIndex : Int + get() = this.size - 1 + +public inline val DoubleArray.lastIndex : Int + get() = this.size - 1 + +public inline val CharArray.lastIndex : Int + get() = this.size - 1 + +public inline val Array.lastIndex : Int + get() = this.size - 1 diff --git a/libraries/stdlib/src/kotlin/Strings.kt b/libraries/stdlib/src/kotlin/Strings.kt index 81945388444..901289a101a 100644 --- a/libraries/stdlib/src/kotlin/Strings.kt +++ b/libraries/stdlib/src/kotlin/Strings.kt @@ -60,6 +60,8 @@ public inline fun String.format(format : String, vararg args : Any?) : String = public inline fun String.split(regex : String) : Array = (this as java.lang.String).split(regex) as Array +public inline fun String.split(ch : Char) : Array = (this as java.lang.String).split(java.util.regex.Pattern.quote(ch.toString())) as Array + public inline fun String.substring(beginIndex : Int) : String = (this as java.lang.String).substring(beginIndex).sure() public inline fun String.substring(beginIndex : Int, endIndex : Int) : String = (this as java.lang.String).substring(beginIndex, endIndex).sure() @@ -68,10 +70,14 @@ public inline fun String.startsWith(prefix: String) : Boolean = (this as java.la public inline fun String.startsWith(prefix: String, toffset: Int) : Boolean = (this as java.lang.String).startsWith(prefix, toffset) +public inline fun String.startsWith(ch: Char) : Boolean = (this as java.lang.String).startsWith(ch.toString()) + public inline fun String.contains(seq: CharSequence) : Boolean = (this as java.lang.String).contains(seq) public inline fun String.endsWith(suffix: String) : Boolean = (this as java.lang.String).endsWith(suffix) +public inline fun String.endsWith(ch: Char) : Boolean = (this as java.lang.String).endsWith(ch.toString()) + inline val String.size : Int get() = length() @@ -226,4 +232,4 @@ public inline fun String.count(predicate: (Char) -> Boolean): Int { } } return answer -} \ No newline at end of file +} diff --git a/libraries/stdlib/src/kotlin/io/Files.kt b/libraries/stdlib/src/kotlin/io/Files.kt index 54d654c29f5..52b24387fab 100644 --- a/libraries/stdlib/src/kotlin/io/Files.kt +++ b/libraries/stdlib/src/kotlin/io/Files.kt @@ -3,6 +3,8 @@ package kotlin.io import java.io.* import java.nio.charset.* import java.util.NoSuchElementException +import java.util.List +import java.util.ArrayList import java.net.URL @@ -147,3 +149,56 @@ public fun File.copyTo(file: File, bufferSize: Int = defaultBufferSize): Long { } } } + +/** + * Reads file by byte blocks and calls closure for each block read. Block size depends on implementation but never less than 512. + * This functions passes byte array and amount of bytes in this buffer to the closure function. + * + * You can use this function for huge files + */ +fun File.forEachBlock(closure : (ByteArray, Int) -> Unit) : Unit { + val arr = ByteArray(4096) + val fis = FileInputStream(this) + + try { + do { + val size = fis.read(arr) + if (size == -1) { + break + } else if (size > 0) { + closure(arr, size) + } + } while(true) + } finally { + fis.close() + } +} + +/** + * Reads file line by line. Default charset is UTF-8. + * + * You may use this function on huge files + */ +fun File.forEachLine (charset : String = "UTF-8", closure : (line : String) -> Unit) : Unit { + val reader = BufferedReader(InputStreamReader(FileInputStream(this), charset)) + try { + reader.forEachLine(closure) + } finally { + reader.close() + } +} + +/** + * Reads file content as strings list. By default uses UTF-8 charset. + * + * Do not use this function for huge files. + */ +fun File.readLines(charset : String = "UTF-8") : List { + val rs = ArrayList() + + this.forEachLine(charset) { (line : String) : Unit -> + rs.add(line); + } + + return rs +} diff --git a/libraries/stdlib/test/ArraysTest.kt b/libraries/stdlib/test/ArraysTest.kt index 4fe0f3b133b..77620c63610 100644 --- a/libraries/stdlib/test/ArraysTest.kt +++ b/libraries/stdlib/test/ArraysTest.kt @@ -39,4 +39,22 @@ class ArraysTest() : TestCase() { assertFalse(iter.hasNext, "Invalid length (hasNext)") } + fun testEmptyArrayLastIndex() { + val arr1 = IntArray(0) + assertEquals(-1, arr1.lastIndex) + + val arr2 = Array(0, {"$it"}) + assertEquals(-1, arr2.lastIndex) + } + + fun testArrayLastIndex() { + val arr1 = intArray(0, 1, 2, 3, 4) + assertEquals(4, arr1.lastIndex) + assertEquals(4, arr1[arr1.lastIndex]) + + val arr2 = Array(5, {"$it"}) + assertEquals(4, arr2.lastIndex) + assertEquals("4", arr2[arr2.lastIndex]) + } + } diff --git a/libraries/stdlib/test/StringTest.kt b/libraries/stdlib/test/StringTest.kt index 157a61a2851..f2db543a24c 100644 --- a/libraries/stdlib/test/StringTest.kt +++ b/libraries/stdlib/test/StringTest.kt @@ -52,4 +52,30 @@ class StringTest { assertEquals(3, whitespaceCount) } + test fun testSplitByChar() { + val s = "ab\n[|^$&\\]^cd" + var list = s.split('b'); + assertEquals(2, list.size) + assertEquals("a", list[0]) + assertEquals("\n[|^$&\\]^cd", list[1]) + list = s.split('^') + assertEquals(3, list.size) + assertEquals("cd", list[2]) + list = s.split('.') + assertEquals(1, list.size) + assertEquals(s, list[0]) + } + + test fun testStartsWithChar() { + assertTrue("abcd".startsWith('a')) + assertFalse("abcd".startsWith('b')) + assertFalse("".startsWith('a')) + } + + test fun testEndsWithChar() { + assertTrue("abcd".endsWith('d')) + assertFalse("abcd".endsWith('b')) + assertFalse("".endsWith('a')) + } + } diff --git a/libraries/tools/kdoc-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/doc/KDocMojo.java b/libraries/tools/kdoc-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/doc/KDocMojo.java index 83c99535bef..d2dea0a4266 100644 --- a/libraries/tools/kdoc-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/doc/KDocMojo.java +++ b/libraries/tools/kdoc-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/doc/KDocMojo.java @@ -17,8 +17,8 @@ package org.jetbrains.kotlin.maven.doc; import org.apache.maven.plugin.MojoExecutionException; -import org.jetbrains.jet.cli.CompilerArguments; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; import org.jetbrains.kotlin.doc.KDocArguments; import org.jetbrains.kotlin.doc.KDocCompiler; import org.jetbrains.kotlin.doc.KDocConfig; @@ -164,17 +164,17 @@ public class KDocMojo extends KotlinCompileMojoBase { private Map packageSummaryText; @Override - protected KotlinCompiler createCompiler() { + protected K2JVMCompiler createCompiler() { return new KDocCompiler(); } @Override - protected CompilerArguments createCompilerArguments() { + protected K2JVMCompilerArguments createCompilerArguments() { return new KDocArguments(); } @Override - protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException { + protected void configureCompilerArguments(K2JVMCompilerArguments arguments) throws MojoExecutionException { configureBaseCompilerArguments(getLog(), arguments, docModule, sources, classpath, output); if (arguments instanceof KDocArguments) { diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/JavadocStyleHtmlDoclet.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/JavadocStyleHtmlDoclet.kt index 847452d3c28..ad2e696fc1b 100644 --- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/JavadocStyleHtmlDoclet.kt +++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/JavadocStyleHtmlDoclet.kt @@ -15,7 +15,7 @@ import java.util.* import com.intellij.psi.PsiElement import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.resolve.BindingContext.* -import org.jetbrains.jet.compiler.CompilerPlugin +import org.jetbrains.jet.cli.common.CompilerPlugin import org.jetbrains.jet.lang.psi.JetFile import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor import org.jetbrains.jet.lexer.JetTokens diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDoc.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDoc.kt index b4496becf97..afdd10c5f1a 100644 --- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDoc.kt +++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDoc.kt @@ -15,7 +15,7 @@ import java.util.Collection import com.intellij.psi.PsiElement import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.resolve.BindingContext.* -import org.jetbrains.jet.compiler.CompilerPlugin +import org.jetbrains.jet.cli.common.CompilerPlugin import org.jetbrains.jet.lang.psi.JetFile import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor import org.jetbrains.jet.lexer.JetTokens diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocCompiler.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocCompiler.kt index a4256f29f55..2bdb2416de5 100644 --- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocCompiler.kt +++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/KDocCompiler.kt @@ -2,25 +2,25 @@ package org.jetbrains.kotlin.doc import java.io.File import java.io.PrintStream -import org.jetbrains.jet.cli.CompilerArguments -import org.jetbrains.jet.cli.KotlinCompiler -import org.jetbrains.jet.compiler.CompileEnvironmentConfiguration +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments +import org.jetbrains.jet.cli.jvm.K2JVMCompiler +import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration import org.jetbrains.kotlin.doc.highlighter.HtmlCompilerPlugin /** * Main for running the KDocCompiler */ fun main(args: Array): Unit { - KotlinCompiler.doMain(KDocCompiler(), args); + K2JVMCompiler.doMain(KDocCompiler(), args); } /** - * A version of the [[KotlinCompiler]] which includes the [[KDoc]] compiler plugin and allows + * A version of the [[K2JVMCompiler]] which includes the [[KDoc]] compiler plugin and allows * command line validation or for the configuration to be provided via [[KDocArguments]] */ -class KDocCompiler() : KotlinCompiler() { +class KDocCompiler() : K2JVMCompiler() { - protected override fun configureEnvironment(configuration : CompileEnvironmentConfiguration?, arguments : CompilerArguments?) { + protected override fun configureEnvironment(configuration : CompileEnvironmentConfiguration?, arguments : K2JVMCompilerArguments?) { super.configureEnvironment(configuration, arguments) val coreEnvironment = configuration?.getEnvironment() if (coreEnvironment != null) { @@ -38,7 +38,7 @@ class KDocCompiler() : KotlinCompiler() { } } - protected override fun createArguments() : CompilerArguments? { + protected override fun createArguments() : K2JVMCompilerArguments? { return KDocArguments() } @@ -47,7 +47,7 @@ class KDocCompiler() : KotlinCompiler() { } } -class KDocArguments() : CompilerArguments() { +class KDocArguments() : K2JVMCompilerArguments() { public var docConfig: KDocConfig = KDocConfig() diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/highlighter/HtmlCompilerPlugin.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/highlighter/HtmlCompilerPlugin.kt index b9dc146e952..188b375b6b9 100644 --- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/highlighter/HtmlCompilerPlugin.kt +++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/highlighter/HtmlCompilerPlugin.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.doc.highlighter -import org.jetbrains.jet.compiler.CompilerPlugin -import org.jetbrains.jet.compiler.CompilerPluginContext +import org.jetbrains.jet.cli.common.CompilerPlugin +import org.jetbrains.jet.cli.common.CompilerPluginContext /** */ diff --git a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KModelCompilerPlugin.kt b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KModelCompilerPlugin.kt index 26aa13b2462..47852604562 100644 --- a/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KModelCompilerPlugin.kt +++ b/libraries/tools/kdoc/src/main/kotlin/org/jetbrains/kotlin/doc/model/KModelCompilerPlugin.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.doc.model -import org.jetbrains.jet.compiler.CompilerPlugin -import org.jetbrains.jet.compiler.CompilerPluginContext +import org.jetbrains.jet.cli.common.CompilerPlugin +import org.jetbrains.jet.cli.common.CompilerPluginContext import org.jetbrains.kotlin.doc.KDocConfig /** Base class for any compiler plugin which needs to process a KModel */ diff --git a/libraries/tools/kdoc/src/test/kotlin/test/kotlin/kdoc/HtmlVisitorTest.kt b/libraries/tools/kdoc/src/test/kotlin/test/kotlin/kdoc/HtmlVisitorTest.kt index 2c9a8977659..7b873d58922 100644 --- a/libraries/tools/kdoc/src/test/kotlin/test/kotlin/kdoc/HtmlVisitorTest.kt +++ b/libraries/tools/kdoc/src/test/kotlin/test/kotlin/kdoc/HtmlVisitorTest.kt @@ -2,8 +2,8 @@ package test.kotlin.kdoc import java.io.File import kotlin.test.assertTrue -import org.jetbrains.jet.cli.CompilerArguments -import org.jetbrains.jet.cli.KotlinCompiler +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments +import org.jetbrains.jet.cli.jvm.K2JVMCompiler import org.jetbrains.kotlin.doc.highlighter.HtmlCompilerPlugin import org.junit.Test @@ -20,12 +20,12 @@ class HtmlVisitorTest { val outDir = File(dir, "target/htmldocs") println("Generating source HTML to $outDir") - val args = CompilerArguments() + val args = K2JVMCompilerArguments() args.setSrc(srcDir.toString()) args.setOutputDir(File(dir, "target/classes-htmldocs").toString()) args.getCompilerPlugins()?.add(HtmlCompilerPlugin()) - val compiler = KotlinCompiler() + val compiler = K2JVMCompiler() compiler.exec(System.out, args) } } \ No newline at end of file diff --git a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerMojo.java b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerMojo.java index 9cfb8dfb3cf..769a12ea9ba 100644 --- a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerMojo.java +++ b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerMojo.java @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.maven; import org.apache.maven.plugin.MojoExecutionException; -import org.jetbrains.jet.cli.CompilerArguments; +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments; /** * Converts Kotlin to JavaScript code @@ -36,7 +36,7 @@ public class K2JSCompilerMojo extends KotlinCompileMojo { private String outFile; @Override - protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException { + protected void configureCompilerArguments(K2JVMCompilerArguments arguments) throws MojoExecutionException { super.configureCompilerArguments(arguments); K2JSCompilerPlugin plugin = new K2JSCompilerPlugin(); diff --git a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerPlugin.java b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerPlugin.java index 25962fe74ff..18eeafe73ce 100644 --- a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerPlugin.java +++ b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JSCompilerPlugin.java @@ -19,8 +19,8 @@ package org.jetbrains.kotlin.maven; import com.google.common.io.Files; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.compiler.CompilerPlugin; -import org.jetbrains.jet.compiler.CompilerPluginContext; +import org.jetbrains.jet.cli.common.CompilerPlugin; +import org.jetbrains.jet.cli.common.CompilerPluginContext; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.k2js.config.Config; diff --git a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojo.java b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojo.java index cf87d2b4d6c..2e2edbb5868 100644 --- a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojo.java +++ b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojo.java @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.maven; import org.apache.maven.plugin.MojoExecutionException; -import org.jetbrains.jet.cli.CompilerArguments; +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments; /** * Compiles kotlin sources @@ -29,7 +29,7 @@ import org.jetbrains.jet.cli.CompilerArguments; */ public class KotlinCompileMojo extends KotlinCompileMojoBase { @Override - protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException { + protected void configureCompilerArguments(K2JVMCompilerArguments arguments) throws MojoExecutionException { configureBaseCompilerArguments(getLog(), arguments, module, sources, classpath, output); } } diff --git a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java index ee10c5baf34..95db5cd5dfc 100644 --- a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java +++ b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinCompileMojoBase.java @@ -23,8 +23,10 @@ import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugin.logging.Log; -import org.jetbrains.jet.cli.CompilerArguments; -import org.jetbrains.jet.cli.KotlinCompiler; +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments; +import org.jetbrains.jet.cli.jvm.K2JVMCompiler; +import org.jetbrains.jet.cli.common.ExitCode.*; +import org.jetbrains.jet.cli.common.ExitCode; import java.io.File; import java.io.IOException; @@ -104,15 +106,15 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo { @Override public void execute() throws MojoExecutionException, MojoFailureException { - final CompilerArguments arguments = createCompilerArguments(); + final K2JVMCompilerArguments arguments = createCompilerArguments(); configureCompilerArguments(arguments); - final KotlinCompiler compiler = createCompiler(); + final K2JVMCompiler compiler = createCompiler(); printCompilerArgumentsIfDebugEnabled(arguments, compiler); - final KotlinCompiler.ExitCode exitCode = compiler.exec(System.err, arguments); + final ExitCode exitCode = compiler.exec(System.err, arguments); switch (exitCode) { case COMPILATION_ERROR: @@ -123,7 +125,7 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo { } } - private void printCompilerArgumentsIfDebugEnabled(CompilerArguments arguments, KotlinCompiler compiler) { + private void printCompilerArgumentsIfDebugEnabled(K2JVMCompilerArguments arguments, K2JVMCompiler compiler) { if (getLog().isDebugEnabled()) { getLog().debug("Invoking compiler " + compiler + " with arguments:"); try { @@ -142,24 +144,24 @@ public abstract class KotlinCompileMojoBase extends AbstractMojo { } } - protected KotlinCompiler createCompiler() { - return new KotlinCompiler(); + protected K2JVMCompiler createCompiler() { + return new K2JVMCompiler(); } /** * Derived classes can create custom compiler argument implementations * such as for KDoc */ - protected CompilerArguments createCompilerArguments() { - return new CompilerArguments(); + protected K2JVMCompilerArguments createCompilerArguments() { + return new K2JVMCompilerArguments(); } /** * Derived classes can register custom plugins or configurations */ - protected abstract void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException; + protected abstract void configureCompilerArguments(K2JVMCompilerArguments arguments) throws MojoExecutionException; - protected void configureBaseCompilerArguments(Log log, CompilerArguments arguments, String module, + protected void configureBaseCompilerArguments(Log log, K2JVMCompilerArguments arguments, String module, List sources, List classpath, String output) throws MojoExecutionException { // don't include runtime, it should be in maven dependencies arguments.mode = "stdlib"; diff --git a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinTestCompileMojo.java b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinTestCompileMojo.java index afaccba1cba..03a00389bf3 100644 --- a/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinTestCompileMojo.java +++ b/libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/KotlinTestCompileMojo.java @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.maven; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; -import org.jetbrains.jet.cli.CompilerArguments; +import org.jetbrains.jet.cli.jvm.K2JVMCompilerArguments; /** * Compiles Kotlin test sources @@ -47,7 +47,7 @@ public class KotlinTestCompileMojo extends KotlinCompileMojoBase { } @Override - protected void configureCompilerArguments(CompilerArguments arguments) throws MojoExecutionException { + protected void configureCompilerArguments(K2JVMCompilerArguments arguments) throws MojoExecutionException { configureBaseCompilerArguments( getLog(), arguments, testModule, testSources, testClasspath, testOutput);