diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 0b577fedb1c..e9483184889 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -277,14 +277,17 @@ public class ExpressionCodegen extends JetVisitor { v.mark(begin); v.load(iteratorVar, asmIterType); - FunctionDescriptor hND; if(hasNextDescriptor instanceof FunctionDescriptor) { - hND = (FunctionDescriptor) hasNextDescriptor; + FunctionDescriptor hND = (FunctionDescriptor) hasNextDescriptor; + invokeFunctionNoParams(hND, Type.BOOLEAN_TYPE, v); } else { - hND = ((PropertyDescriptor) hasNextDescriptor).getGetter(); +// hND = ((PropertyDescriptor) hasNextDescriptor).getGetter(); +// if(hND != null) +// invokeFunctionNoParams(hND, Type.BOOLEAN_TYPE, v); +// else + intermediateValueForProperty((PropertyDescriptor) hasNextDescriptor, false, false).put(Type.BOOLEAN_TYPE, v); } - invokeFunctionNoParams(hND, Type.BOOLEAN_TYPE, v); v.ifeq(end); myMap.enter(parameterDescriptor, asmParamType.getSize()); @@ -598,8 +601,10 @@ public class ExpressionCodegen extends JetVisitor { } for (DeclarationDescriptor descriptor : closureCodegen.closure.keySet()) { - final Type sharedVarType = getSharedVarType(descriptor); - consArgTypes.add(sharedVarType != null ? sharedVarType : state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getOutType())); + Type sharedVarType = getSharedVarType(descriptor); + if(sharedVarType == null) + sharedVarType = state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getOutType()); + consArgTypes.add(sharedVarType); final EnclosedValueDescriptor valueDescriptor = closureCodegen.closure.get(descriptor); valueDescriptor.getOuterValue().put(sharedVarType, v); } @@ -1462,7 +1467,7 @@ public class ExpressionCodegen extends JetVisitor { return StackValue.onStack(Type.BOOLEAN_TYPE); } - private StackValue generateEqualsForExpressionsOnStack(IElementType opToken, Type leftType, Type rightType, boolean leftNullable, boolean rightNullable) { + public StackValue generateEqualsForExpressionsOnStack(IElementType opToken, Type leftType, Type rightType, boolean leftNullable, boolean rightNullable) { if (isNumberPrimitive(leftType) && leftType == rightType) { return compareExpressionsOnStack(opToken, leftType); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 5dd9bf9f711..97ea22a1428 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -342,7 +342,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Map closure = context.closure.closure; int k = 0; for (DeclarationDescriptor varDescr : closure.keySet()) { - final Type sharedVarType = context.closure.exprContext.getSharedVarType(varDescr); + Type sharedVarType = context.closure.exprContext.getSharedVarType(varDescr); + if(sharedVarType == null) { + sharedVarType = state.getTypeMapper().mapType(((VariableDescriptor) varDescr).getOutType()); + } iv.load(0, JetTypeMapper.TYPE_OBJECT); iv.load(firstClosureIndex + k, StackValue.refType(sharedVarType)); iv.putfield(state.getTypeMapper().jvmName(descriptor, OwnerKind.IMPLEMENTATION), "$" + (k+1), sharedVarType.getDescriptor()); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 926b496e243..947cf407491 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -39,6 +39,7 @@ public class JetTypeMapper { public static final Type JL_BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean"); public static final Type JL_NUMBER_TYPE = Type.getObjectType("java/lang/Number"); public static final Type JL_STRING_BUILDER = Type.getObjectType("java/lang/StringBuilder"); + public static final Type JL_STRING_TYPE = Type.getObjectType("java/lang/String"); public static final Type ARRAY_INT_TYPE = Type.getType(int[].class); public static final Type ARRAY_LONG_TYPE = Type.getType(long[].class); @@ -59,15 +60,15 @@ public class JetTypeMapper { public static final Type TYPE_FUNCTION1 = Type.getObjectType("jet/Function1"); public static final Type TYPE_ITERATOR = Type.getObjectType("jet/Iterator"); public static final Type TYPE_INT_RANGE = Type.getObjectType("jet/IntRange"); - public static final Type TYPE_SHARED_VAR = Type.getObjectType("jet/refs/SharedVar$Object"); - public static final Type TYPE_SHARED_INT = Type.getObjectType("jet/refs/SharedVar$Int"); - public static final Type TYPE_SHARED_DOUBLE = Type.getObjectType("jet/refs/SharedVar$Double"); - public static final Type TYPE_SHARED_FLOAT = Type.getObjectType("jet/refs/SharedVar$Float"); - public static final Type TYPE_SHARED_BYTE = Type.getObjectType("jet/refs/SharedVar$Byte"); - public static final Type TYPE_SHARED_SHORT = Type.getObjectType("jet/refs/SharedVar$Short"); - public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/refs/SharedVar$Char"); - public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/refs/SharedVar$Long"); - public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/refs/SharedVar$Boolean"); + public static final Type TYPE_SHARED_VAR = Type.getObjectType("jet/runtime/SharedVar$Object"); + public static final Type TYPE_SHARED_INT = Type.getObjectType("jet/runtime/SharedVar$Int"); + public static final Type TYPE_SHARED_DOUBLE = Type.getObjectType("jet/runtime/SharedVar$Double"); + public static final Type TYPE_SHARED_FLOAT = Type.getObjectType("jet/runtime/SharedVar$Float"); + public static final Type TYPE_SHARED_BYTE = Type.getObjectType("jet/runtime/SharedVar$Byte"); + public static final Type TYPE_SHARED_SHORT = Type.getObjectType("jet/runtime/SharedVar$Short"); + public static final Type TYPE_SHARED_CHAR = Type.getObjectType("jet/runtime/SharedVar$Char"); + public static final Type TYPE_SHARED_LONG = Type.getObjectType("jet/runtime/SharedVar$Long"); + public static final Type TYPE_SHARED_BOOLEAN = Type.getObjectType("jet/runtime/SharedVar$Boolean"); public JetTypeMapper(JetStandardLibrary standardLibrary, BindingContext bindingContext) { this.standardLibrary = standardLibrary; @@ -460,7 +461,10 @@ public class JetTypeMapper { parameterTypes.add(type); } for (ValueParameterDescriptor parameter : parameters) { - final Type type = mapType(parameter.getOutType()); + Type type = mapType(parameter.getOutType()); + if(parameter.isVararg()) { + type = Type.getType("[" + type.getDescriptor()); + } valueParameterTypes.add(type); parameterTypes.add(type); } @@ -558,7 +562,13 @@ public class JetTypeMapper { parameterTypes.add(mapType(receiver.getType())); } for (ValueParameterDescriptor parameter : parameters) { - parameterTypes.add(mapType(parameter.getOutType())); + if(parameter.isVararg()) { + Type type = mapType(parameter.getOutType()); + type = Type.getType("[" + type.getDescriptor()); + parameterTypes.add(type); + } + else + parameterTypes.add(mapType(parameter.getOutType())); } Type returnType = mapReturnType(f.getReturnType()); return new Method(name, returnType, parameterTypes.toArray(new Type[parameterTypes.size()])); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java index c61130a7b15..902026b2014 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java @@ -31,31 +31,31 @@ public class ArrayIterator implements IntrinsicMethod { JetStandardLibrary standardLibrary = codegen.getState().getStandardLibrary(); if(containingDeclaration.equals(standardLibrary.getArray())) { codegen.generateTypeInfo(funDescriptor.getReturnType().getArguments().get(0).getType()); - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/typeinfo/TypeInfo;)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;Ljet/typeinfo/TypeInfo;)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getByteArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([B)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([B)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getShortArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([S)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([S)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getIntArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([I)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([I)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getLongArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([J)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([J)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getFloatArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([F)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([F)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getDoubleArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([D)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([D)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getCharArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([C)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([C)Ljet/Iterator;"); } else if(containingDeclaration.equals(standardLibrary.getBooleanArrayClass())) { - v.invokestatic("jet/arrays/ArrayIterator", "iterator", "([Z)Ljet/Iterator;"); + v.invokestatic("jet/runtime/ArrayIterator", "iterator", "([Z)Ljet/Iterator;"); } else { throw new UnsupportedOperationException(containingDeclaration.toString()); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Equals.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Equals.java new file mode 100644 index 00000000000..8a9280c0102 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Equals.java @@ -0,0 +1,43 @@ +package org.jetbrains.jet.codegen.intrinsics; + +import com.intellij.psi.PsiElement; +import com.intellij.psi.tree.IElementType; +import org.jetbrains.jet.codegen.ExpressionCodegen; +import org.jetbrains.jet.codegen.JetTypeMapper; +import org.jetbrains.jet.codegen.StackValue; +import org.jetbrains.jet.lang.psi.JetCallExpression; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lexer.JetTokens; +import org.objectweb.asm.Type; +import org.objectweb.asm.commons.InstructionAdapter; + +import java.util.List; + +/** + * @author alex.tkachman + */ +public class Equals implements IntrinsicMethod { + @Override + public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List arguments, StackValue receiver) { + receiver.put(JetTypeMapper.TYPE_OBJECT, v); + + boolean leftNullable = true; + if(element instanceof JetCallExpression) { + JetCallExpression jetCallExpression = (JetCallExpression) element; + JetExpression calleeExpression = jetCallExpression.getCalleeExpression(); + if(calleeExpression != null) { + JetType leftType = codegen.getBindingContext().get(BindingContext.EXPRESSION_TYPE, calleeExpression); + if(leftType != null) + leftNullable = leftType.isNullable(); + } + } + + JetExpression rightExpr = arguments.get(0); + JetType rightType = codegen.getBindingContext().get(BindingContext.EXPRESSION_TYPE, rightExpr); + codegen.gen(rightExpr).put(JetTypeMapper.TYPE_OBJECT, v); + + return codegen.generateEqualsForExpressionsOnStack(JetTokens.EQEQ, JetTypeMapper.TYPE_OBJECT, JetTypeMapper.TYPE_OBJECT, leftNullable, rightType.isNullable()); + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java index b1efba96116..edda1e0f96b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java @@ -73,6 +73,11 @@ public class IntrinsicMethods { declareIntrinsicFunction("String", "plus", 1, new Concat()); + declareOverload(myStdLib.getLibraryScope().getFunctions("toString"), 0, new ToString()); + declareOverload(myStdLib.getLibraryScope().getFunctions("equals"), 1, new Equals()); + +// declareIntrinsicFunction("Any", "equals", 1, new Equals()); +// declareIntrinsicStringMethods(); declareIntrinsicProperty("String", "length", new StringLength()); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java new file mode 100644 index 00000000000..18e706a4b1f --- /dev/null +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java @@ -0,0 +1,24 @@ +package org.jetbrains.jet.codegen.intrinsics; + +import com.intellij.psi.PsiElement; +import org.jetbrains.jet.codegen.ExpressionCodegen; +import org.jetbrains.jet.codegen.JetTypeMapper; +import org.jetbrains.jet.codegen.StackValue; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.types.JetStandardClasses; +import org.objectweb.asm.Type; +import org.objectweb.asm.commons.InstructionAdapter; + +import java.util.List; + +/** + * @author alex.tkachman + */ +public class ToString implements IntrinsicMethod { + @Override + public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List arguments, StackValue receiver) { + receiver.put(JetTypeMapper.TYPE_OBJECT, v); + v.invokestatic("java/lang/String", "valueOf", "(Ljava/lang/Object;)Ljava/lang/String;"); + return StackValue.onStack(JetTypeMapper.JL_STRING_TYPE); + } +} diff --git a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java index 9d943679e2b..cc998dd0ac8 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/KotlinCompiler.java @@ -1,6 +1,6 @@ package org.jetbrains.jet.cli; -import com.google.common.collect.Lists; +import com.google.common.collect.*; import com.intellij.core.JavaCoreEnvironment; import com.intellij.openapi.Disposable; import com.intellij.openapi.project.Project; @@ -8,10 +8,15 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; +import com.sampullara.cli.Args; +import com.sampullara.cli.Argument; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; +import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; +import org.jetbrains.jet.lang.diagnostics.DiagnosticWithTextRange; +import org.jetbrains.jet.lang.diagnostics.Severity; import org.jetbrains.jet.lang.parsing.JetParserDefinition; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespace; @@ -24,16 +29,30 @@ import java.io.File; import java.io.IOException; import java.net.URL; import java.net.URLClassLoader; +import java.util.Collection; import java.util.List; /** * @author yole + * @author alex.tkachman */ public class KotlinCompiler { + public static class Arguments { + @Argument(value = "output", description = "output directory") + public String outputDir; + @Argument(value = "src", description = "source file or directory", required = true) + public String src; + } + public static void main(String[] args) { System.setProperty("java.awt.headless", "true"); - if (args.length < 1) { - System.out.println("Usage: KotlinCompiler "); + Arguments arguments = new Arguments(); + try { + Args.parse(arguments, args); + } + catch (Throwable t) { + System.out.println("Usage: KotlinCompiler -output -src "); + t.printStackTrace(); return; } @@ -44,6 +63,119 @@ public class KotlinCompiler { }; JavaCoreEnvironment environment = new JavaCoreEnvironment(root); + File rtJar = initJdk(); + if (rtJar == null) return; + + environment.addToClasspath(rtJar); + + environment.registerFileType(JetFileType.INSTANCE, "kt"); + environment.registerParserDefinition(new JetParserDefinition()); + + VirtualFile vFile = environment.getLocalFileSystem().findFileByPath(arguments.src); + if (vFile == null) { + System.out.print("File/directory not found: " + arguments.src); + return; + } + + Project project = environment.getProject(); + GenerationState generationState = new GenerationState(project, false); + List namespaces = Lists.newArrayList(); + if(vFile.isDirectory()) { + File dir = new File(vFile.getPath()); + addFiles(environment, project, namespaces, dir); + } + else { + PsiFile psiFile = PsiManager.getInstance(project).findFile(vFile); + if (psiFile instanceof JetFile) { + namespaces.add(((JetFile) psiFile).getRootNamespace()); + } + else { + System.out.print("Not a Kotlin file: " + vFile.getPath()); + return; + } + } + + BindingContext bindingContext = AnalyzingUtils.getInstance(JavaDefaultImports.JAVA_DEFAULT_IMPORTS).analyzeNamespaces(project, namespaces, JetControlFlowDataTraceFactory.EMPTY); + + ErrorCollector errorCollector = new ErrorCollector(bindingContext); + errorCollector.report(); + + if (!errorCollector.hasErrors) { + generationState.compileCorrectNamespaces(bindingContext, namespaces); + + final ClassFileFactory factory = generationState.getFactory(); + if(arguments.outputDir == null) { + System.out.println("Output directory is not specified - no files will be saved to the disk"); + } + else { + List files = factory.files(); + for (String file : files) { + File target = new File(arguments.outputDir, file); + try { + FileUtil.writeToFile(target, factory.asBytes(file)); + System.out.println("Generated classfile: " + target); + } catch (IOException e) { + System.out.println(e.getMessage()); + } + } + } + } + + } + + private static class ErrorCollector { + Multimap maps = LinkedHashMultimap.create(); + + boolean hasErrors; + + public ErrorCollector(BindingContext bindingContext) { + for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { + report(diagnostic); + } + } + + private void report(Diagnostic diagnostic) { + hasErrors |= diagnostic.getSeverity() == Severity.ERROR; + if(diagnostic instanceof DiagnosticWithTextRange) { + DiagnosticWithTextRange diagnosticWithTextRange = (DiagnosticWithTextRange) diagnostic; + maps.put(diagnosticWithTextRange.getPsiFile(), diagnosticWithTextRange); + } + else { + System.out.println(diagnostic.getSeverity().toString() + ": " + diagnostic.getMessage()); + } + } + + void report() { + if(!maps.isEmpty()) { + for (PsiFile psiFile : maps.keySet()) { + System.out.println(psiFile.getVirtualFile().getPath()); + Collection diagnosticWithTextRanges = maps.get(psiFile); + for (DiagnosticWithTextRange diagnosticWithTextRange : diagnosticWithTextRanges) { + String position = DiagnosticUtils.formatPosition(diagnosticWithTextRange); + System.out.println("\t" + diagnosticWithTextRange.getSeverity().toString() + ": " + position + " " + diagnosticWithTextRange.getMessage()); + } + } + } + } + + } + + private static void addFiles(JavaCoreEnvironment environment, Project project, List namespaces, File dir) { + for(File file : dir.listFiles()) { + if(!file.isDirectory()) { + VirtualFile virtualFile = environment.getLocalFileSystem().findFileByPath(file.getAbsolutePath()); + PsiFile psiFile = PsiManager.getInstance(project).findFile(virtualFile); + if (psiFile instanceof JetFile) { + namespaces.add(((JetFile) psiFile).getRootNamespace()); + } + } + else { + addFiles(environment, project, namespaces, file); + } + } + } + + private static File initJdk() { String javaHome = System.getenv("JAVA_HOME"); File rtJar = null; if (javaHome == null) { @@ -66,7 +198,7 @@ public class KotlinCompiler { if(rtJar == null) { System.out.println("JAVA_HOME environment variable needs to be defined"); - return; + return null; } } else { @@ -75,70 +207,9 @@ public class KotlinCompiler { if (rtJar == null || !rtJar.exists()) { System.out.print("No rt.jar found under JAVA_HOME=" + javaHome); - return; + return null; } - - environment.addToClasspath(rtJar); - - environment.registerFileType(JetFileType.INSTANCE, "kt"); - environment.registerFileType(JetFileType.INSTANCE, "jet"); - environment.registerParserDefinition(new JetParserDefinition()); - VirtualFile vFile = environment.getLocalFileSystem().findFileByPath(args [0]); - if (vFile == null) { - System.out.print("File not found: " + args[0]); - return; - } - - Project project = environment.getProject(); - GenerationState generationState = new GenerationState(project, false); - List namespaces = Lists.newArrayList(); - PsiFile psiFile = PsiManager.getInstance(project).findFile(vFile); - if (psiFile instanceof JetFile) { - namespaces.add(((JetFile) psiFile).getRootNamespace()); - } - else { - System.out.print("Not a Kotlin file: " + vFile.getPath()); - return; - } - - BindingContext bindingContext = AnalyzingUtils.getInstance(JavaDefaultImports.JAVA_DEFAULT_IMPORTS).analyzeNamespaces(project, namespaces, JetControlFlowDataTraceFactory.EMPTY); - - boolean errors = false; - for (Diagnostic diagnostic : bindingContext.getDiagnostics()) { - switch (diagnostic.getSeverity()) { - case ERROR: - errors = true; - report(diagnostic); - break; - case INFO: - report(diagnostic); - break; - case WARNING: - report(diagnostic); - break; - } - } - - if (!errors) { - generationState.compileCorrectNamespaces(bindingContext, namespaces); - - final ClassFileFactory factory = generationState.getFactory(); - List files = factory.files(); - for (String file : files) { - File target = new File(vFile.getParent().getPath(), file); - try { - FileUtil.writeToFile(target, factory.asBytes(file)); - System.out.println("Generated classfile: " + target); - } catch (IOException e) { - System.out.println(e.getMessage()); - } - } - } - - } - - private static void report(Diagnostic diagnostic) { - System.out.println(diagnostic.getMessage()); + return rtJar; } private static File findRtJar(String javaHome) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java index f6d6f2f001d..2176cb879b3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java @@ -20,4 +20,7 @@ public class JavaDefaultImports { rootScope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices)); } }; + + private JavaDefaultImports() { + } } diff --git a/compiler/frontend/src/jet/Library.jet b/compiler/frontend/src/jet/Library.jet index 0a57bbf4c91..296cd1038e6 100644 --- a/compiler/frontend/src/jet/Library.jet +++ b/compiler/frontend/src/jet/Library.jet @@ -41,8 +41,8 @@ fun Any?.equals(other : Any?) : Boolean// = this === other fun Any?.toString() : String// = this === other trait Iterator { - fun next() : T - fun hasNext() : Boolean + fun next() : T + val hasNext : Boolean } trait Iterable { 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 ea3d2d57700..0ff433add71 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java @@ -63,4 +63,22 @@ public class DiagnosticUtils { return "' at offset " + offset + " (line unknown)" + pathSuffix; } } + + public static String formatPosition(DiagnosticWithTextRange diagnosticWithTextRange) { + PsiFile file = diagnosticWithTextRange.getPsiFile(); + Document document = file.getViewProvider().getDocument(); + String position; + int offset = diagnosticWithTextRange.getTextRange().getStartOffset(); + if (document != null) { + int lineNumber = document.getLineNumber(offset); + int lineStartOffset = document.getLineStartOffset(lineNumber); + int column = offset - lineStartOffset; + + position = "(" + (lineNumber + 1) + "," + column + ")"; + } + else { + position = "(offset: " + offset + " line unknown)"; + } + return position; + } } 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 6637d0bedec..9ab713325aa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java @@ -1429,7 +1429,7 @@ public class JetParsing extends AbstractJetParsing { /* * functionType - * : "fun" (type ".")? functionTypeContents + * : "fun" (type ".")? "(" (parameter | modifiers type){","} ")" (":" type)? // Unit by default * ; */ private void parseFunctionType() { @@ -1446,22 +1446,15 @@ public class JetParsing extends AbstractJetParsing { advance(); // DOT } - parseFunctionTypeContents(); - - functionType.done(FUNCTION_TYPE); - } - - /* - * functionTypeContents - * : "(" (parameter | type){","} ")" ":" type - * ; - */ - private void parseFunctionTypeContents() { parseValueParameterList(true, TokenSet.EMPTY); - expect(COLON, "Expecting ':' followed by a return type", TYPE_REF_FIRST); + if (at(COLON)) { + advance(); // COLON // expect(COLON, "Expecting ':' followed by a return type", TYPE_REF_FIRST); - parseTypeRef(); + parseTypeRef(); + } + + functionType.done(FUNCTION_TYPE); } /* 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 9b00c34e64a..416a0b54e5d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java @@ -70,6 +70,11 @@ public class DelegatingBindingTrace implements BindingTrace { } } + public void clear() { + map.clear(); + diagnostics.clear(); + } + @Override public void report(@NotNull Diagnostic diagnostic) { diagnostics.add(diagnostic); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java index 9d7f3fd1a18..fef2b6a9e1a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java @@ -11,6 +11,7 @@ public class TemporaryBindingTrace extends DelegatingBindingTrace { private final BindingTrace trace; + private TemporaryBindingTrace(BindingTrace trace) { super(trace.getBindingContext()); this.trace = trace; @@ -18,5 +19,6 @@ public class TemporaryBindingTrace extends DelegatingBindingTrace { public void commit() { addAllMyDataTo(trace); + clear(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index 76c23ca970d..fd60a354043 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -105,12 +105,9 @@ public class TypeResolver { } else { if (actualArgumentCount != expectedArgumentCount) { -// String errorMessage = (expectedArgumentCount == 0 ? "No" : expectedArgumentCount) + " type arguments expected"; if (actualArgumentCount == 0) { -// trace.getErrorHandler().genericError(type.getNode(), errorMessage); trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type, expectedArgumentCount)); } else { -// trace.getErrorHandler().genericError(type.getTypeArgumentList().getNode(), errorMessage); trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type.getTypeArgumentList(), expectedArgumentCount)); } } else { @@ -160,10 +157,14 @@ public class TypeResolver { } JetTypeReference returnTypeRef = type.getReturnTypeRef(); + JetType returnType; if (returnTypeRef != null) { - JetType returnType = resolveType(scope, returnTypeRef); - result[0] = JetStandardClasses.getFunctionType(annotations, receiverType, parameterTypes, returnType); + returnType = resolveType(scope, returnTypeRef); } + else { + returnType = JetStandardClasses.getUnitType(); + } + result[0] = JetStandardClasses.getFunctionType(annotations, receiverType, parameterTypes, returnType); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 3840d59e444..976d5b9c070 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -206,8 +206,6 @@ public class CallResolver { @NotNull JetType expectedType, @NotNull final List> prioritizedTasks, // high to low priority @NotNull final JetReferenceExpression reference) { - TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null; - OverloadResolutionResults resultsForFirstNonemptyCandidateSet = null; TracingStrategy tracing = new TracingStrategy() { @Override public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) { @@ -272,12 +270,12 @@ public class CallResolver { } @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) { + public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallNode(), descriptors)); } @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) { + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { trace.report(NONE_APPLICABLE.on(reference, descriptors)); } @@ -323,6 +321,9 @@ public class CallResolver { trace.report(UNNECESSARY_SAFE_CALL.on((JetElement) callOperationNode.getTreeParent().getPsi(), callOperationNode, type)); } }; + + TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null; + OverloadResolutionResults resultsForFirstNonemptyCandidateSet = null; for (ResolutionTask task : prioritizedTasks) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); OverloadResolutionResults results = performResolution(temporaryTrace, scope, expectedType, task, tracing); @@ -479,6 +480,14 @@ public class CallResolver { task.performAdvancedChecks(candidate, temporaryTrace, tracing); + // 'super' cannot be passed as an argument, for receiver arguments expression typer does not track this + // See TaskPrioritizer for more + JetSuperExpression superExpression = TaskPrioritizer.getReceiverSuper(candidateCall.getReceiverArgument()); + if (superExpression != null) { + temporaryTrace.report(SUPER_IS_NOT_AN_EXPRESSION.on(superExpression, superExpression.getText())); + candidateCall.setStatus(OTHER_ERROR); + } + recordAutoCastIfNecessary(candidateCall.getReceiverArgument(), candidateCall.getTrace()); recordAutoCastIfNecessary(candidateCall.getThisObject(), candidateCall.getTrace()); } @@ -540,21 +549,6 @@ public class CallResolver { } } -// private Function createMapFunction(D substitutedFunctionDescriptor) { -// assert substitutedFunctionDescriptor != null; -// final Map parameterMap = Maps.newHashMap(); -// for (ValueParameterDescriptor valueParameterDescriptor : substitutedFunctionDescriptor.getValueParameters()) { -// parameterMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor); -// } -// -// return new Function() { -// @Override -// public ValueParameterDescriptor apply(ValueParameterDescriptor input) { -// return parameterMap.get(input.getOriginal()); -// } -// }; -// } - private void replaceValueParametersWithSubstitutedOnes(ResolvedCallImpl candidateCall, @NotNull D substitutedDescriptor) { Map parameterMap = Maps.newHashMap(); for (ValueParameterDescriptor valueParameterDescriptor : substitutedDescriptor.getValueParameters()) { @@ -656,30 +650,47 @@ public class CallResolver { Set> successfulCandidates, Set> failedCandidates) { // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific + if (successfulCandidates.size() > 0) { - return chooseAndReportMaximallySpecific(trace, tracing, successfulCandidates); + OverloadResolutionResults results = chooseAndReportMaximallySpecific(successfulCandidates); + if (results.isAmbiguity()) { + // This check is needed for the following case: + // x.foo(unresolved) -- if there are multiple foo's, we'd report an ambiguity, and it does not make sense here + if (allClean(results.getResults())) { + tracing.ambiguity(trace, results.getResults()); + } + tracing.recordAmbiguity(trace, results.getResults()); + } + return results; } else if (!failedCandidates.isEmpty()) { if (failedCandidates.size() != 1) { - Set> weakErrors = Sets.newLinkedHashSet(); - for (ResolvedCallImpl candidate : failedCandidates) { - if (candidate.getStatus().isWeakError()) { - weakErrors.add(candidate); - } - } - if (!weakErrors.isEmpty()) { - OverloadResolutionResults results = chooseAndReportMaximallySpecific(trace, tracing, weakErrors); - if (results.isSuccess()) { - return OverloadResolutionResults.singleFailedCandidate(results.getResult()); + // This is needed when there are several overloads some of which are OK but for nullability of the receiver, + // and some are not OK at all. In this case we'd like to say "unsafe call" rather than "none applicable" + // Used to be: weak errors. Generalized for future extensions + for (EnumSet severityLevel : SEVERITY_LEVELS) { + Set> thisLevel = Sets.newLinkedHashSet(); + for (ResolvedCallImpl candidate : failedCandidates) { + if (severityLevel.contains(candidate.getStatus())) { + thisLevel.add(candidate); + } } + if (!thisLevel.isEmpty()) { + OverloadResolutionResults results = chooseAndReportMaximallySpecific(thisLevel); + if (results.isSuccess()) { + results.getResult().getTrace().commit(); + return OverloadResolutionResults.singleFailedCandidate(results.getResult()); + } - return OverloadResolutionResults.manyFailedCandidates(results.getResults()); + tracing.noneApplicable(trace, results.getResults()); + tracing.recordAmbiguity(trace, results.getResults()); + return OverloadResolutionResults.manyFailedCandidates(results.getResults()); + } } + assert false : "Should not be reachable, cause every status must belong to some level"; Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); if (noOverrides.size() != 1) { -// tracing.reportOverallResolutionError(trace, "None of the following functions can be called with the arguments supplied: " -// + makeErrorMessageForMultipleDescriptors(noOverrides)); tracing.noneApplicable(trace, noOverrides); tracing.recordAmbiguity(trace, noOverrides); return OverloadResolutionResults.manyFailedCandidates(noOverrides); @@ -696,15 +707,20 @@ public class CallResolver { } } - private OverloadResolutionResults chooseAndReportMaximallySpecific(BindingTrace trace, TracingStrategy tracing, Set> candidates) { + private boolean allClean(Collection> results) { + for (ResolvedCallImpl result : results) { + if (result.isDirty()) return false; + } + return true; + } + + private OverloadResolutionResults chooseAndReportMaximallySpecific(Set> candidates) { if (candidates.size() != 1) { Set> cleanCandidates = Sets.newLinkedHashSet(candidates); - boolean allClean = true; for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { ResolvedCallImpl candidate = iterator.next(); if (candidate.isDirty()) { iterator.remove(); - allClean = false; } } @@ -722,13 +738,6 @@ public class CallResolver { } Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); - if (allClean) { -// tracing.reportOverallResolutionError(trace, "Overload resolution ambiguity: " -// + makeErrorMessageForMultipleDescriptors(noOverrides)); - tracing.ambiguity(trace, noOverrides); - } - - tracing.recordAmbiguity(trace, noOverrides); return OverloadResolutionResults.ambiguity(noOverrides); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionStatus.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionStatus.java index 7c9c5406285..78253d24466 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionStatus.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionStatus.java @@ -1,5 +1,7 @@ package org.jetbrains.jet.lang.resolve.calls; +import java.util.EnumSet; + /** * @author abreslav */ @@ -9,7 +11,14 @@ public enum ResolutionStatus { OTHER_ERROR, SUCCESS(true); + @SuppressWarnings("unchecked") + public static final EnumSet[] SEVERITY_LEVELS = new EnumSet[] { + EnumSet.of(UNSAFE_CALL_ERROR), // weakest + EnumSet.of(OTHER_ERROR), // most severe + }; + private final boolean success; + private int severityIndex = -1; private ResolutionStatus(boolean success) { this.success = success; @@ -25,11 +34,21 @@ public enum ResolutionStatus { public ResolutionStatus combine(ResolutionStatus other) { if (this.isSuccess()) return other; - if (this.isWeakError() && !other.isSuccess()) return other; + if (!other.isSuccess() && this.getSeverityIndex() < other.getSeverityIndex()) return other; return this; } + + private int getSeverityIndex() { + if (severityIndex == -1) { + for (int i = 0; i < SEVERITY_LEVELS.length; i++) { + if (SEVERITY_LEVELS[i].contains(this)) { + severityIndex = i; + break; + } + } + } + assert severityIndex >= 0; - public boolean isWeakError() { - return this == UNSAFE_CALL_ERROR; + return severityIndex; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java index 5bfc0947a8e..3b02eb27f0e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java @@ -2,16 +2,20 @@ package org.jetbrains.jet.lang.resolve.calls; import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.psi.Call; +import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.psi.JetSuperExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastService; import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeChecker; @@ -72,6 +76,18 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor return false; } + @Nullable + /*package*/ static JetSuperExpression getReceiverSuper(@NotNull ReceiverDescriptor receiver) { + if (receiver instanceof ExpressionReceiver) { + ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiver; + JetExpression expression = expressionReceiver.getExpression(); + if (expression instanceof JetSuperExpression) { + return (JetSuperExpression) expression; + } + } + return null; + } + public List> computePrioritizedTasks(@NotNull JetScope scope, @NotNull Call call, @NotNull String name, @NotNull BindingContext bindingContext, @NotNull DataFlowInfo dataFlowInfo) { List> result = Lists.newArrayList(); @@ -108,8 +124,17 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members); } - addTask(result, call, locals, dataFlowInfo); - addTask(result, call, members, dataFlowInfo); + if (getReceiverSuper(receiver) != null) { + // If the call is of the form super.foo(), it can actually be only a member + // But if there's no appropriate member, we would like to report that super cannot be a receiver for an extension + // Thus, put members first + addTask(result, call, members, dataFlowInfo); + addTask(result, call, locals, dataFlowInfo); + } + else { + addTask(result, call, locals, dataFlowInfo); + addTask(result, call, members, dataFlowInfo); + } for (ReceiverDescriptor implicitReceiver : implicitReceivers) { Collection memberExtensions = getExtensionsByName(implicitReceiver.getType().getMemberScope(), name); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java index 6284ccb5b0d..d06b99d2068 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java @@ -8,7 +8,6 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import java.util.Collection; -import java.util.Set; /** * @author abreslav @@ -40,10 +39,10 @@ import java.util.Set; public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {} @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} + public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) {} @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) {} @Override public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {} @@ -74,9 +73,9 @@ import java.util.Set; void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount); - void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors); + void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors); - void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors); + void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors); void instantiationOfAbstractClass(@NotNull BindingTrace trace); diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java index a3706523fbf..32dfe3d17bf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java +++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/MutableSlicedMap.java @@ -8,4 +8,6 @@ public interface MutableSlicedMap extends SlicedMap { void put(WritableSlice slice, K key, V value); V remove(RemovableSlice slice, K key); + + void clear(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java index 36dbf297929..70182bb6ee4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java @@ -47,6 +47,11 @@ public class SlicedMapImpl implements MutableSlicedMap { slice.afterPut(this, key, value); } + @Override + public void clear() { + map.clear(); + } + @Override public V get(ReadOnlySlice slice, K key) { SlicedMapKey slicedMapKey = slice.makeKey(key); diff --git a/compiler/testData/checkerWithErrorTypes/quick/ExtensionsCalledOnSuper.jet b/compiler/testData/checkerWithErrorTypes/quick/ExtensionsCalledOnSuper.jet new file mode 100644 index 00000000000..fe072bcc632 --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/ExtensionsCalledOnSuper.jet @@ -0,0 +1,21 @@ +trait T { + fun foo() {} + fun buzz() {} + fun buzz1(i : Int) {} +} + +fun T.bar() {} + +fun T.buzz() {} +fun T.buzz1() {} + +class C : T { + fun test() { + fun T.buzz() {} + fun T.buzz1() {} + super.foo() // OK + super.bar() // Error + super.buzz() // OK, resolved to a member + super.buzz1() // Resolved to a member, but error: no parameter passed where required + } +} \ No newline at end of file diff --git a/compiler/testData/checkerWithErrorTypes/quick/Super.jet b/compiler/testData/checkerWithErrorTypes/quick/Super.jet index 5ec4cfdcb00..5841b9108f3 100644 --- a/compiler/testData/checkerWithErrorTypes/quick/Super.jet +++ b/compiler/testData/checkerWithErrorTypes/quick/Super.jet @@ -1,5 +1,17 @@ namespace example; +fun any(a : Any) {} + +fun notAnExpression() { + any(super) // not an expression + if (super) {} else {} // not an expression + val x = super // not an expression + when (1) { + super => 1 // not an expression + } + +} + trait T { fun foo() {} } @@ -72,6 +84,6 @@ class ERROR() : UR { // No supertype at all class A1 { fun test() { - super.equals(null) + super.equals(null) } } \ No newline at end of file diff --git a/compiler/testData/checkerWithErrorTypes/quick/UnitByDefaultForFunctionTypes.jet b/compiler/testData/checkerWithErrorTypes/quick/UnitByDefaultForFunctionTypes.jet new file mode 100644 index 00000000000..383e67e16c4 --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/UnitByDefaultForFunctionTypes.jet @@ -0,0 +1,3 @@ +fun foo(f : fun()) { + val x : Unit = f() +} \ No newline at end of file diff --git a/compiler/testData/checkerWithErrorTypes/quick/regressions/UnavaliableQualifiedThis.jet b/compiler/testData/checkerWithErrorTypes/quick/regressions/UnavaliableQualifiedThis.jet new file mode 100644 index 00000000000..301ded436a1 --- /dev/null +++ b/compiler/testData/checkerWithErrorTypes/quick/regressions/UnavaliableQualifiedThis.jet @@ -0,0 +1,13 @@ +trait Iterator { + fun next() : T + val hasNext : Boolean + + fun map(transform: fun(element: T) : R) : Iterator = + object : Iterator { + override fun next() : R = transform(this@map.next()) + + override val hasNext : Boolean + // There's no 'this' associated with the map() function, only this of the Iterator class + get() = this@map.hasNext + } +} diff --git a/compiler/testData/codegen/controlStructures/forUserType.jet b/compiler/testData/codegen/controlStructures/forUserType.jet index 0332dc28bf1..cd2e335196d 100644 --- a/compiler/testData/codegen/controlStructures/forUserType.jet +++ b/compiler/testData/codegen/controlStructures/forUserType.jet @@ -88,7 +88,8 @@ class MyCollection2(): Iterable { var k : Int = 5 override fun next() : Int = k-- - override fun hasNext() = k > 0 + override val hasNext : Boolean + get() = k > 0 } } @@ -99,7 +100,8 @@ class MyCollection3() { var k : Int = 5 fun next() : Int? = k-- - fun hasNext() = k > 0 + val hasNext : Boolean + get() = k > 0 } } diff --git a/idea/testData/psi/Super.jet b/compiler/testData/psi/Super.jet similarity index 100% rename from idea/testData/psi/Super.jet rename to compiler/testData/psi/Super.jet diff --git a/idea/testData/psi/Super.txt b/compiler/testData/psi/Super.txt similarity index 100% rename from idea/testData/psi/Super.txt rename to compiler/testData/psi/Super.txt diff --git a/idea/testData/resolve/Super.jet b/compiler/testData/resolve/Super.jet similarity index 100% rename from idea/testData/resolve/Super.jet rename to compiler/testData/resolve/Super.jet diff --git a/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java index f5f89630aa5..76d4f93928c 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ArrayGenTest.java @@ -56,42 +56,42 @@ public class ArrayGenTest extends CodegenTestCase { } public void testIterator () throws Exception { - loadText("fun box() { val x = Array(5, { it } ).iterator(); while(x.hasNext()) { java.lang.System.out?.println(x.next()) } }"); + loadText("fun box() { val x = Array(5, { it } ).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }"); System.out.println(generateToText()); Method foo = generateFunction(); foo.invoke(null); } public void testPrimitiveIterator () throws Exception { - loadText("fun box() { val x = ByteArray(5).iterator(); while(x.hasNext()) { java.lang.System.out?.println(x.next()) } }"); + loadText("fun box() { val x = ByteArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }"); System.out.println(generateToText()); Method foo = generateFunction(); foo.invoke(null); } public void testLongIterator () throws Exception { - loadText("fun box() { val x = LongArray(5).iterator(); while(x.hasNext()) { java.lang.System.out?.println(x.next()) } }"); + loadText("fun box() { val x = LongArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }"); System.out.println(generateToText()); Method foo = generateFunction(); foo.invoke(null); } public void testCharIterator () throws Exception { - loadText("fun box() { val x = CharArray(5).iterator(); while(x.hasNext()) { java.lang.System.out?.println(x.next()) } }"); + loadText("fun box() { val x = CharArray(5).iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }"); System.out.println(generateToText()); Method foo = generateFunction(); foo.invoke(null); } public void testArrayIndices () throws Exception { - loadText("fun box() { val x = Array(5, {it}).indices.iterator(); while(x.hasNext()) { java.lang.System.out?.println(x.next()) } }"); + loadText("fun box() { val x = Array(5, {it}).indices.iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }"); System.out.println(generateToText()); Method foo = generateFunction(); foo.invoke(null); } public void testCharIndices () throws Exception { - loadText("fun box() { val x = CharArray(5).indices.iterator(); while(x.hasNext()) { java.lang.System.out?.println(x.next()) } }"); + loadText("fun box() { val x = CharArray(5).indices.iterator(); while(x.hasNext) { java.lang.System.out?.println(x.next()) } }"); System.out.println(generateToText()); Method foo = generateFunction(); foo.invoke(null); diff --git a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java index 130148eb40b..da0ecc0dd4b 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java @@ -1,5 +1,8 @@ package org.jetbrains.jet.codegen; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + /** * @author alex.tkachman */ @@ -13,4 +16,29 @@ public class FunctionGenTest extends CodegenTestCase { blackBoxFile("functions/nothisnoclosure.jet"); System.out.println(generateToText()); } + + public void testAnyToString () throws InvocationTargetException, IllegalAccessException { + loadText("fun foo(x: Any) = x.toString()"); + System.out.println(generateToText()); + Method foo = generateFunction(); + assertEquals("something", foo.invoke(null, "something")); + assertEquals("null", foo.invoke(null, new Object[]{null})); + + } + + public void testAnyEqualsNullable () throws InvocationTargetException, IllegalAccessException { + loadText("fun foo(x: Any?) = x.equals(\"lala\")"); + System.out.println(generateToText()); + Method foo = generateFunction(); + assertTrue((Boolean) foo.invoke(null, "lala")); + assertFalse((Boolean) foo.invoke(null, "mama")); + } + + public void testAnyEquals () throws InvocationTargetException, IllegalAccessException { + loadText("fun foo(x: Any) = x.equals(\"lala\")"); + System.out.println(generateToText()); + Method foo = generateFunction(); + assertTrue((Boolean) foo.invoke(null, "lala")); + assertFalse((Boolean) foo.invoke(null, "mama")); + } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java b/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java new file mode 100644 index 00000000000..9dca1094568 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/codegen/VarArgTest.java @@ -0,0 +1,29 @@ +package org.jetbrains.jet.codegen; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * @author alex.tkachman + */ +public class VarArgTest extends CodegenTestCase { + public void testStringArray () throws InvocationTargetException, IllegalAccessException { + /* + loadText("fun test(vararg ts: String) = ts"); + System.out.println(generateToText()); + final Method main = generateFunction(); + Object[] args = {"mama", "papa"}; + assertTrue(args == main.invoke(null, args)); + */ + } + + public void testIntArray () throws InvocationTargetException, IllegalAccessException { + /* + loadText("fun test(vararg ts: Int) = ts"); + System.out.println(generateToText()); + final Method main = generateFunction(); + int[] args = {3, 4}; + assertTrue(args == main.invoke(null, args)); + */ + } +} diff --git a/examples/src/collections/HashMap.jetl b/examples/src/collections/HashMap.jetl index ac690682d89..b7dc8d37f46 100644 --- a/examples/src/collections/HashMap.jetl +++ b/examples/src/collections/HashMap.jetl @@ -1,15 +1,15 @@ -open class IEquality { +trait IEquality { fun equals(other : Any) : Boolean = (this as java.lang.Object).equals(other as java.lang.Object) } -open class IHashable : IEquality { +trait IHashable : IEquality { val hashCode : Integer get() = (this as java.lang.Object).hashCode() } -open class IMap { +trait IMap { fun get(key : K) : V fun set(key : K, value : V) : V fun remove(key : K) : V @@ -21,7 +21,7 @@ class HashableWrapper wraps (val obj : Any) : IHashable [inline] fun Any.hashable() : HashableWrapper = new HashableWrapper(this) -open class IHashingStrategy { +trait IHashingStrategy { fun equals(a : K, b : K) : Boolean fun hashCode(a : K) : Integer } diff --git a/examples/src/collections/IIterable.jetl b/examples/src/collections/IIterable.jetl deleted file mode 100644 index c9a55af4058..00000000000 --- a/examples/src/collections/IIterable.jetl +++ /dev/null @@ -1,3 +0,0 @@ -open class IIterable { - fun iterator() : IIterator -} diff --git a/examples/src/collections/IIterable.kt b/examples/src/collections/IIterable.kt new file mode 100644 index 00000000000..ae5dbdc0a51 --- /dev/null +++ b/examples/src/collections/IIterable.kt @@ -0,0 +1,9 @@ +namespace jet.collections.iterable + +import jet.collections.iterator.IIterator + +trait IIterable { + fun iterator() : IIterator + + inline fun foreach(operation: fun(element: T) : Unit) = iterator() foreach operation +} diff --git a/examples/src/collections/IIterator.jetl b/examples/src/collections/IIterator.jetl deleted file mode 100644 index 1739eae7a01..00000000000 --- a/examples/src/collections/IIterator.jetl +++ /dev/null @@ -1,25 +0,0 @@ -open class IIterator { - fun next() : T - val hasNext : Boolean - - fun toArray(buffer : MutableArray) : Int { // T is still an in-parameter - return fillBuffer(buffer, 0, buffer.size) - } - - fun toArray(buffer : MutableArray, from : Int, length : Int) : Int { // T is still an in-parameter - if (from < 0 || from > buffer.lastIndex || length < 0 || length > buffer.size - from) { - throw IndexOutOfBoundsException(); - } - - if (len == 0) return 0 - - var count = 0; - for (i in from .. from + length - 1) { - if (!hasNext) - return count - buffer[i] = next() - count++ - } - return count - } -} diff --git a/examples/src/collections/IList.jetl b/examples/src/collections/IList.jetl deleted file mode 100644 index 69fff05ca87..00000000000 --- a/examples/src/collections/IList.jetl +++ /dev/null @@ -1,4 +0,0 @@ -open class IList : IIterable, ISized { - [operator] fun get(index : Int) : T - val isEmpty : Boolean -} \ No newline at end of file diff --git a/examples/src/collections/IList.kt b/examples/src/collections/IList.kt new file mode 100644 index 00000000000..7f887a3a539 --- /dev/null +++ b/examples/src/collections/IList.kt @@ -0,0 +1,3 @@ +trait IList : IIterable, ISized { + fun get(index : Int) : T +} \ No newline at end of file diff --git a/examples/src/collections/ISet.jetl b/examples/src/collections/ISet.jetl deleted file mode 100644 index 0b6741470fd..00000000000 --- a/examples/src/collections/ISet.jetl +++ /dev/null @@ -1,3 +0,0 @@ -open class ISet : IIterable, ISized { - fun contains(item : T) : Boolean -} diff --git a/examples/src/collections/ISet.kt b/examples/src/collections/ISet.kt new file mode 100644 index 00000000000..8b3b375fa32 --- /dev/null +++ b/examples/src/collections/ISet.kt @@ -0,0 +1,8 @@ +namespace jet.collections.set + +import jet.collections.sized.ISized +import jet.collections.iterable.IIterable + +trait ISet : IIterable, ISized { + fun contains(item : T) : Boolean +} diff --git a/examples/src/collections/ISized.jetl b/examples/src/collections/ISized.jetl deleted file mode 100644 index 5e5977f253e..00000000000 --- a/examples/src/collections/ISized.jetl +++ /dev/null @@ -1,3 +0,0 @@ -open class ISized { - val size : Int -} \ No newline at end of file diff --git a/examples/src/collections/ISized.kt b/examples/src/collections/ISized.kt new file mode 100644 index 00000000000..80f6fdd6a05 --- /dev/null +++ b/examples/src/collections/ISized.kt @@ -0,0 +1,11 @@ +namespace jet.collections.sized + +trait ISized { + val size : Int + + val isEmpty : Boolean + get() = size == 0 + + val isNonEmpty : Boolean + get() = size != 0 +} \ No newline at end of file diff --git a/examples/src/collections/Iterator.kt b/examples/src/collections/Iterator.kt new file mode 100644 index 00000000000..0e8bfac5277 --- /dev/null +++ b/examples/src/collections/Iterator.kt @@ -0,0 +1,170 @@ +namespace jet.collections + +import java.util.NoSuchElementException + +trait Iterator { + fun next() : T + val hasNext : Boolean + + fun map(transform: fun(element: T) : R) : Iterator = + object : Iterator { + override fun next() : R = transform(this@map.next()) + + override val hasNext : Boolean + get() = this@map.hasNext + } +} + +trait ISized { + val size : Int +} + +val ISized.isEmpty : Boolean + get() = size == 0 + +val ISized.isNonEmpty : Boolean + get() = size != 0 + +trait ISet : Iterable, ISized { + fun contains(item : T) : Boolean +} + +trait IList : Iterable, ISized { + fun get(index : Int) : T + + fun iterator() : Iterator = + object Iterator { + var index = 0 + + override fun next() : T = get(index++) + + override val hasNext : Boolean + get() = index < size + } + + fun toArray() : Array = Array(size) { index => get(index) } +} + +fun Array.asList() : IList = object IList { + override val size + get() = this@Array.size + + override fun get(index: Int) = this@asList[index] +} + +fun Iterator.foreach(operation: fun(element: T) : Unit) : Unit = while(hasNext) operation(next()) + +fun Iterator.foreach(operation: fun(index: Int, element: T) : Unit) : Unit { + var k = 0 + while(hasNext) + operation(k++, next()) +} + +fun Iterable.foreach(operation: fun(element: T) : Unit) : Unit = iterator() foreach operation + +fun Iterable.foreach(operation: fun(index: Int, element: T) : Unit) : Unit = iterator() foreach operation + +fun Iterable.foldLeft(init: R, operation: fun(accumulated: R, element: T) : R) : R = + iterator () foreach operation + +fun Iterable.foldLeft(init: R, operation: fun(accumulated: R, index: Int, element: T) : R) : R = + iterator () foreach operation + +fun Iterator.foldLeft(init: R, operation: fun(accumulated: R, element: T) : R) : R { + while(hasNext) + init = operation(init, next()) + return init +} + +fun Iterator.foldLeft(init: R, operation: fun(accumulated: R, index: Int, element: T) : R) : R { + var k = 0 + while(hasNext) + init = operation(init, k++, next()) + return init +} + +fun Iterator.map(transform: fun(element: T) : R) : Iterator = + object : Iterator { + override fun next() : R = transform(this@map.next()) + + override val hasNext : Boolean + get() = this@map.hasNext + } + +fun Iterator.map(transform: fun(index: Int, element: T) : R) : Iterator { + return object : Iterator { + var index = 0 + + override fun next() : R = transform(index++, this@map.next()) + + override val hasNext : Boolean + get() = this@map.hasNext + } +} + +fun Iterator.plus(other: Iterator) : Iterator = + object : Iterator { + override fun next() : T = if(this@plus.hasNext) this@plus.next() else other.next() + + override val hasNext : Boolean + get() = this@plus.hasNext || other.hasNext + } + +fun Iterator.filter(condition: fun(element: T) : Boolean) : Iterator { + return object : Iterator { + private var _next : T = null + private var _lookedAhead : Boolean = false + private var _hasNext : Boolean = false + + private fun lookAhead() : Boolean { + if(!_lookedAhead) { + _lookedAhead = true + while(this@filter.hasNext) { + _next = this@filter.next() + if(condition(_next)) { + _hasNext = true + return true + } + } + } + return _hasNext + } + + override fun next() : T { + lookAhead() + _lookedAhead = false + if(_hasNext) { + val res = _next + _next = null + _hasNext = false + return res + } + throw NoSuchElementException() + } + + override val hasNext : Boolean + get() = lookAhead() + } +} +/* + fun toArray(buffer : MutableArray) : Int { // T is still an in-parameter + return fillBuffer(buffer, 0, buffer.size) + } + + fun toArray(buffer : MutableArray, from : Int, length : Int) : Int { // T is still an in-parameter + if (from < 0 || from > buffer.lastIndex || length < 0 || length > buffer.size - from) { + throw IndexOutOfBoundsException(); + } + + if (len == 0) return 0 + + var count = 0; + for (i in from .. from + length - 1) { + if (!hasNext) + return count + buffer[i] = next() + count++ + } + return count + } +*/ diff --git a/grammar/src/types.grm b/grammar/src/types.grm index a0c3ce44679..b92457e67ce 100644 --- a/grammar/src/types.grm +++ b/grammar/src/types.grm @@ -47,11 +47,7 @@ optionalProjection ; functionType - : "fun" (type ".")? functionTypeContents - ; - -functionTypeContents - : "(" (parameter | modifiers /*lazy out ref*/ type){","} ")" ":" type + : "fun" (type ".")? "(" (parameter | modifiers /*lazy out ref*/ type){","} ")" (":" type)? // Unit by default ; tupleType diff --git a/stdlib/src/jet/ExtensionFunction1.java b/stdlib/src/jet/ExtensionFunction1.java index 2a75a41acf6..3036473a0f6 100644 --- a/stdlib/src/jet/ExtensionFunction1.java +++ b/stdlib/src/jet/ExtensionFunction1.java @@ -1,19 +1,19 @@ /* - * @author max + * @author alex.tkachman */ package jet; import jet.typeinfo.TypeInfo; - -public abstract class ExtensionFunction1 extends DefaultJetObject{ +public abstract class ExtensionFunction1 extends DefaultJetObject { protected ExtensionFunction1(TypeInfo typeInfo) { super(typeInfo); } - public abstract R invoke(E receiver, D d); + public abstract R invoke(E receiver, D1 d1); @Override public String toString() { - return "{E.(d: D) : R}"; + return "{E.(d1: D1) : R)}"; } } + diff --git a/stdlib/src/jet/ExtensionFunction10.java b/stdlib/src/jet/ExtensionFunction10.java new file mode 100644 index 00000000000..a840c84675c --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction10.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction10 extends DefaultJetObject { + protected ExtensionFunction10(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction11.java b/stdlib/src/jet/ExtensionFunction11.java new file mode 100644 index 00000000000..161a2635dfc --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction11.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction11 extends DefaultJetObject { + protected ExtensionFunction11(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction12.java b/stdlib/src/jet/ExtensionFunction12.java new file mode 100644 index 00000000000..286b76250f8 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction12.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction12 extends DefaultJetObject { + protected ExtensionFunction12(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction13.java b/stdlib/src/jet/ExtensionFunction13.java new file mode 100644 index 00000000000..6e498216343 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction13.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction13 extends DefaultJetObject { + protected ExtensionFunction13(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction14.java b/stdlib/src/jet/ExtensionFunction14.java new file mode 100644 index 00000000000..129899f7d23 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction14.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction14 extends DefaultJetObject { + protected ExtensionFunction14(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction15.java b/stdlib/src/jet/ExtensionFunction15.java new file mode 100644 index 00000000000..650b4597b3c --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction15.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction15 extends DefaultJetObject { + protected ExtensionFunction15(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction16.java b/stdlib/src/jet/ExtensionFunction16.java new file mode 100644 index 00000000000..782911bb1b6 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction16.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction16 extends DefaultJetObject { + protected ExtensionFunction16(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction17.java b/stdlib/src/jet/ExtensionFunction17.java new file mode 100644 index 00000000000..9a690ecc852 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction17.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction17 extends DefaultJetObject { + protected ExtensionFunction17(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction18.java b/stdlib/src/jet/ExtensionFunction18.java new file mode 100644 index 00000000000..ed7fed24fdc --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction18.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction18 extends DefaultJetObject { + protected ExtensionFunction18(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction19.java b/stdlib/src/jet/ExtensionFunction19.java new file mode 100644 index 00000000000..2db3e66aaa2 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction19.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction19 extends DefaultJetObject { + protected ExtensionFunction19(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction2.java b/stdlib/src/jet/ExtensionFunction2.java index a7ffa19687a..bf5ccd43d4e 100644 --- a/stdlib/src/jet/ExtensionFunction2.java +++ b/stdlib/src/jet/ExtensionFunction2.java @@ -1,11 +1,10 @@ /* - * @author max + * @author alex.tkachman */ package jet; import jet.typeinfo.TypeInfo; - -public abstract class ExtensionFunction2 extends DefaultJetObject{ +public abstract class ExtensionFunction2 extends DefaultJetObject { protected ExtensionFunction2(TypeInfo typeInfo) { super(typeInfo); } @@ -14,6 +13,7 @@ public abstract class ExtensionFunction2 extends DefaultJetObjec @Override public String toString() { - return "{E.(d1: D1, d2: D2) : R}"; + return "{E.(d1: D1, d2: D2) : R)}"; } } + diff --git a/stdlib/src/jet/ExtensionFunction20.java b/stdlib/src/jet/ExtensionFunction20.java new file mode 100644 index 00000000000..f3466d13499 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction20.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction20 extends DefaultJetObject { + protected ExtensionFunction20(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19, d20: D20) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction21.java b/stdlib/src/jet/ExtensionFunction21.java new file mode 100644 index 00000000000..43f7bb1bde0 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction21.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction21 extends DefaultJetObject { + protected ExtensionFunction21(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20, D21 d21); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19, d20: D20, d21: D21) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction22.java b/stdlib/src/jet/ExtensionFunction22.java new file mode 100644 index 00000000000..04296ce8b0e --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction22.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction22 extends DefaultJetObject { + protected ExtensionFunction22(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20, D21 d21, D22 d22); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19, d20: D20, d21: D21, d22: D22) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction3.java b/stdlib/src/jet/ExtensionFunction3.java index 54dd96f5f32..8c5518f8c4c 100644 --- a/stdlib/src/jet/ExtensionFunction3.java +++ b/stdlib/src/jet/ExtensionFunction3.java @@ -1,11 +1,10 @@ /* - * @author max + * @author alex.tkachman */ package jet; import jet.typeinfo.TypeInfo; - -public abstract class ExtensionFunction3 extends DefaultJetObject{ +public abstract class ExtensionFunction3 extends DefaultJetObject { protected ExtensionFunction3(TypeInfo typeInfo) { super(typeInfo); } @@ -14,6 +13,7 @@ public abstract class ExtensionFunction3 extends DefaultJetOb @Override public String toString() { - return "{E.(d1: D1, d2: D2, d3: D3) : R}"; + return "{E.(d1: D1, d2: D2, d3: D3) : R)}"; } } + diff --git a/stdlib/src/jet/ExtensionFunction4.java b/stdlib/src/jet/ExtensionFunction4.java new file mode 100644 index 00000000000..67f85720049 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction4.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction4 extends DefaultJetObject { + protected ExtensionFunction4(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction5.java b/stdlib/src/jet/ExtensionFunction5.java new file mode 100644 index 00000000000..702db6aa429 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction5.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction5 extends DefaultJetObject { + protected ExtensionFunction5(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction6.java b/stdlib/src/jet/ExtensionFunction6.java new file mode 100644 index 00000000000..b5be7b846a3 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction6.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction6 extends DefaultJetObject { + protected ExtensionFunction6(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction7.java b/stdlib/src/jet/ExtensionFunction7.java new file mode 100644 index 00000000000..2e854e49b25 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction7.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction7 extends DefaultJetObject { + protected ExtensionFunction7(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction8.java b/stdlib/src/jet/ExtensionFunction8.java new file mode 100644 index 00000000000..d633773ea78 --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction8.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction8 extends DefaultJetObject { + protected ExtensionFunction8(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8) : R)}"; + } +} + diff --git a/stdlib/src/jet/ExtensionFunction9.java b/stdlib/src/jet/ExtensionFunction9.java new file mode 100644 index 00000000000..1c65840d5ae --- /dev/null +++ b/stdlib/src/jet/ExtensionFunction9.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class ExtensionFunction9 extends DefaultJetObject { + protected ExtensionFunction9(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(E receiver, D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9); + + @Override + public String toString() { + return "{E.(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function0.java b/stdlib/src/jet/Function0.java index 67515b604e1..81d32b0b281 100644 --- a/stdlib/src/jet/Function0.java +++ b/stdlib/src/jet/Function0.java @@ -5,8 +5,13 @@ package jet; import jet.typeinfo.TypeInfo; -public abstract class Function0 extends DefaultJetObject { - protected Function0(TypeInfo typeInfo) { +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintStream; + +public abstract class Function0 extends DefaultJetObject { + protected Function0(TypeInfo typeInfo) { super(typeInfo); } @@ -16,4 +21,68 @@ public abstract class Function0 extends DefaultJetObject { public String toString() { return "{() : R}"; } + +// public static void main(String[] args) throws IOException { +// for(int i = 1; i <= 22; i++) { +// PrintStream out = new PrintStream(new File("/Development/Dev.Git/jet/stdlib/src/jet/Function" + i + ".java")); +// out.print("/*\n" + +// " * @author alex.tkachman\n" + +// " */\n" + +// "package jet;\n" + +// "\n" + +// "import jet.typeinfo.TypeInfo;\n" + +// "public abstract class Function" + i + "<"); +// for(int k = 1; k <= i; k++) +// out.print("D" + k + ", "); +// out.println("R> extends DefaultJetObject {\n" + +// " protected Function" + i + "(TypeInfo typeInfo) {\n" + +// " super(typeInfo);\n" + +// " }"); +// +// out.print("\n public abstract R invoke("); +// for(int k = 1; k <= i; k++) +// out.print("D" + k + " d" + k + (k != i ? ", " : ");\n\n")); +// +// out.println(" @Override\n" + +// " public String toString() {"); +// out.print(" return \"{("); +// for(int k = 1; k <= i; k++) +// out.print("d" + k + ": D" + k + (k != i ? ", " : ") : R)}\";\n")); +// out.println(" }"); +// +// out.println("}\n"); +// out.close(); +// } +// +// for(int i = 1; i <= 22; i++) { +// PrintStream out = new PrintStream(new File("/Development/Dev.Git/jet/stdlib/src/jet/ExtensionFunction" + i + ".java")); +// out.print("/*\n" + +// " * @author alex.tkachman\n" + +// " */\n" + +// "package jet;\n" + +// "\n" + +// "import jet.typeinfo.TypeInfo;\n" + +// "public abstract class ExtensionFunction" + i + " extends DefaultJetObject {\n" + +// " protected ExtensionFunction" + i + "(TypeInfo typeInfo) {\n" + +// " super(typeInfo);\n" + +// " }"); +// +// out.print("\n public abstract R invoke(E receiver, "); +// for(int k = 1; k <= i; k++) +// out.print("D" + k + " d" + k + (k != i ? ", " : ");\n\n")); +// +// out.println(" @Override\n" + +// " public String toString() {"); +// out.print(" return \"{E.("); +// for(int k = 1; k <= i; k++) +// out.print("d" + k + ": D" + k + (k != i ? ", " : ") : R)}\";\n")); +// out.println(" }"); +// +// out.println("}\n"); +// out.close(); +// } +// } } diff --git a/stdlib/src/jet/Function1.java b/stdlib/src/jet/Function1.java index 345a47cb0a2..3991ba51dd7 100644 --- a/stdlib/src/jet/Function1.java +++ b/stdlib/src/jet/Function1.java @@ -1,19 +1,19 @@ /* - * @author max + * @author alex.tkachman */ package jet; import jet.typeinfo.TypeInfo; - -public abstract class Function1 extends DefaultJetObject { +public abstract class Function1 extends DefaultJetObject { protected Function1(TypeInfo typeInfo) { super(typeInfo); } - public abstract R invoke(D d); + public abstract R invoke(D1 d1); @Override public String toString() { - return "{(d: D) : R}"; + return "{(d1: D1) : R)}"; } } + diff --git a/stdlib/src/jet/Function10.java b/stdlib/src/jet/Function10.java new file mode 100644 index 00000000000..3d5633fe157 --- /dev/null +++ b/stdlib/src/jet/Function10.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function10 extends DefaultJetObject { + protected Function10(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function11.java b/stdlib/src/jet/Function11.java new file mode 100644 index 00000000000..23ae003d045 --- /dev/null +++ b/stdlib/src/jet/Function11.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function11 extends DefaultJetObject { + protected Function11(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function12.java b/stdlib/src/jet/Function12.java new file mode 100644 index 00000000000..5e7d39422c2 --- /dev/null +++ b/stdlib/src/jet/Function12.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function12 extends DefaultJetObject { + protected Function12(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function13.java b/stdlib/src/jet/Function13.java new file mode 100644 index 00000000000..fe41e408dc6 --- /dev/null +++ b/stdlib/src/jet/Function13.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function13 extends DefaultJetObject { + protected Function13(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function14.java b/stdlib/src/jet/Function14.java new file mode 100644 index 00000000000..9c678ede552 --- /dev/null +++ b/stdlib/src/jet/Function14.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function14 extends DefaultJetObject { + protected Function14(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function15.java b/stdlib/src/jet/Function15.java new file mode 100644 index 00000000000..9bbc6b85394 --- /dev/null +++ b/stdlib/src/jet/Function15.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function15 extends DefaultJetObject { + protected Function15(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function16.java b/stdlib/src/jet/Function16.java new file mode 100644 index 00000000000..7e401a94242 --- /dev/null +++ b/stdlib/src/jet/Function16.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function16 extends DefaultJetObject { + protected Function16(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function17.java b/stdlib/src/jet/Function17.java new file mode 100644 index 00000000000..2c75ba63d76 --- /dev/null +++ b/stdlib/src/jet/Function17.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function17 extends DefaultJetObject { + protected Function17(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function18.java b/stdlib/src/jet/Function18.java new file mode 100644 index 00000000000..1c95e9e8e39 --- /dev/null +++ b/stdlib/src/jet/Function18.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function18 extends DefaultJetObject { + protected Function18(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function19.java b/stdlib/src/jet/Function19.java new file mode 100644 index 00000000000..8f8d5a030a3 --- /dev/null +++ b/stdlib/src/jet/Function19.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function19 extends DefaultJetObject { + protected Function19(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function2.java b/stdlib/src/jet/Function2.java index 170b1969d0e..21f32978e29 100644 --- a/stdlib/src/jet/Function2.java +++ b/stdlib/src/jet/Function2.java @@ -1,11 +1,10 @@ /* - * @author max + * @author alex.tkachman */ package jet; import jet.typeinfo.TypeInfo; - -public abstract class Function2 extends DefaultJetObject { +public abstract class Function2 extends DefaultJetObject { protected Function2(TypeInfo typeInfo) { super(typeInfo); } @@ -14,6 +13,7 @@ public abstract class Function2 extends DefaultJetObject { @Override public String toString() { - return "{(d1: D1, d2: D2) : R}"; + return "{(d1: D1, d2: D2) : R)}"; } } + diff --git a/stdlib/src/jet/Function20.java b/stdlib/src/jet/Function20.java new file mode 100644 index 00000000000..cdf5b11a16e --- /dev/null +++ b/stdlib/src/jet/Function20.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function20 extends DefaultJetObject { + protected Function20(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19, d20: D20) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function21.java b/stdlib/src/jet/Function21.java new file mode 100644 index 00000000000..c213b6079b7 --- /dev/null +++ b/stdlib/src/jet/Function21.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function21 extends DefaultJetObject { + protected Function21(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20, D21 d21); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19, d20: D20, d21: D21) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function22.java b/stdlib/src/jet/Function22.java new file mode 100644 index 00000000000..6aacfa26e84 --- /dev/null +++ b/stdlib/src/jet/Function22.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function22 extends DefaultJetObject { + protected Function22(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9, D10 d10, D11 d11, D12 d12, D13 d13, D14 d14, D15 d15, D16 d16, D17 d17, D18 d18, D19 d19, D20 d20, D21 d21, D22 d22); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9, d10: D10, d11: D11, d12: D12, d13: D13, d14: D14, d15: D15, d16: D16, d17: D17, d18: D18, d19: D19, d20: D20, d21: D21, d22: D22) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function3.java b/stdlib/src/jet/Function3.java index 54380062e6e..ffecf8c9ad1 100644 --- a/stdlib/src/jet/Function3.java +++ b/stdlib/src/jet/Function3.java @@ -1,11 +1,10 @@ /* - * @author max + * @author alex.tkachman */ package jet; import jet.typeinfo.TypeInfo; - -public abstract class Function3 extends DefaultJetObject{ +public abstract class Function3 extends DefaultJetObject { protected Function3(TypeInfo typeInfo) { super(typeInfo); } @@ -14,6 +13,7 @@ public abstract class Function3 extends DefaultJetObject{ @Override public String toString() { - return "{(d1: D1, d2: D2, d3: D3) : R}"; + return "{(d1: D1, d2: D2, d3: D3) : R)}"; } } + diff --git a/stdlib/src/jet/Function4.java b/stdlib/src/jet/Function4.java new file mode 100644 index 00000000000..31fc584ad8f --- /dev/null +++ b/stdlib/src/jet/Function4.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function4 extends DefaultJetObject { + protected Function4(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function5.java b/stdlib/src/jet/Function5.java new file mode 100644 index 00000000000..85655ac1e7e --- /dev/null +++ b/stdlib/src/jet/Function5.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function5 extends DefaultJetObject { + protected Function5(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function6.java b/stdlib/src/jet/Function6.java new file mode 100644 index 00000000000..bf4dfadf09d --- /dev/null +++ b/stdlib/src/jet/Function6.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function6 extends DefaultJetObject { + protected Function6(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function7.java b/stdlib/src/jet/Function7.java new file mode 100644 index 00000000000..ef3691024d4 --- /dev/null +++ b/stdlib/src/jet/Function7.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function7 extends DefaultJetObject { + protected Function7(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function8.java b/stdlib/src/jet/Function8.java new file mode 100644 index 00000000000..0b261a57dfb --- /dev/null +++ b/stdlib/src/jet/Function8.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function8 extends DefaultJetObject { + protected Function8(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8) : R)}"; + } +} + diff --git a/stdlib/src/jet/Function9.java b/stdlib/src/jet/Function9.java new file mode 100644 index 00000000000..5334531aa97 --- /dev/null +++ b/stdlib/src/jet/Function9.java @@ -0,0 +1,19 @@ +/* + * @author alex.tkachman + */ +package jet; + +import jet.typeinfo.TypeInfo; +public abstract class Function9 extends DefaultJetObject { + protected Function9(TypeInfo typeInfo) { + super(typeInfo); + } + + public abstract R invoke(D1 d1, D2 d2, D3 d3, D4 d4, D5 d5, D6 d6, D7 d7, D8 d8, D9 d9); + + @Override + public String toString() { + return "{(d1: D1, d2: D2, d3: D3, d4: D4, d5: D5, d6: D6, d7: D7, d8: D8, d9: D9) : R)}"; + } +} + diff --git a/stdlib/src/jet/IntRange.java b/stdlib/src/jet/IntRange.java index abeb2a0f696..71d49ed0a73 100644 --- a/stdlib/src/jet/IntRange.java +++ b/stdlib/src/jet/IntRange.java @@ -76,7 +76,7 @@ public final class IntRange implements Range, Iterable, JetObj } @Override - public boolean hasNext() { + public boolean getHasNext() { return count > 0; } diff --git a/stdlib/src/jet/Iterator.java b/stdlib/src/jet/Iterator.java index 001bdd83863..f476440b7c4 100644 --- a/stdlib/src/jet/Iterator.java +++ b/stdlib/src/jet/Iterator.java @@ -1,6 +1,6 @@ package jet; public interface Iterator extends JetObject { - boolean hasNext(); + boolean getHasNext(); T next (); } diff --git a/stdlib/src/jet/LongRange.java b/stdlib/src/jet/LongRange.java index 7932f7d0b5d..e0a358599fb 100644 --- a/stdlib/src/jet/LongRange.java +++ b/stdlib/src/jet/LongRange.java @@ -76,7 +76,7 @@ public final class LongRange implements Range, Iterable, JetObject { } @Override - public boolean hasNext() { + public boolean getHasNext() { return count > 0; } diff --git a/stdlib/src/jet/arrays/ArrayIterator.java b/stdlib/src/jet/runtime/ArrayIterator.java similarity index 97% rename from stdlib/src/jet/arrays/ArrayIterator.java rename to stdlib/src/jet/runtime/ArrayIterator.java index 3bbfac045f3..3b57a17636a 100644 --- a/stdlib/src/jet/arrays/ArrayIterator.java +++ b/stdlib/src/jet/runtime/ArrayIterator.java @@ -1,16 +1,14 @@ -package jet.arrays; +package jet.runtime; import jet.Iterator; +import jet.JetObject; import jet.typeinfo.TypeInfo; import jet.typeinfo.TypeInfoProjection; -import java.lang.reflect.GenericArrayType; -import java.util.Arrays; - /** * @author alex.tkachman */ -public abstract class ArrayIterator implements Iterator { +public abstract class ArrayIterator implements Iterator, JetObject { private final int size; protected int index; @@ -19,7 +17,7 @@ public abstract class ArrayIterator implements Iterator { } @Override - public boolean hasNext() { + public boolean getHasNext() { return index < size; } diff --git a/stdlib/src/jet/refs/SharedVar.java b/stdlib/src/jet/runtime/SharedVar.java similarity index 96% rename from stdlib/src/jet/refs/SharedVar.java rename to stdlib/src/jet/runtime/SharedVar.java index 0bd99c66965..e0bc9e93d14 100644 --- a/stdlib/src/jet/refs/SharedVar.java +++ b/stdlib/src/jet/runtime/SharedVar.java @@ -1,4 +1,4 @@ -package jet.refs; +package jet.runtime; public final class SharedVar { public static final class Object {