diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 7f37b9fb423..c292e4af82d 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -7,19 +7,25 @@ - - + + + + + + + + + + + - - - @@ -90,6 +96,45 @@ - + - - + + - + + + + + + + + + + + + + - - + + - + - - + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -180,47 +348,16 @@ - + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + @@ -235,111 +372,26 @@ - - - - - - - - - - - - - - + - + - - + + - - - - - - - - - - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -361,22 +413,22 @@ @@ -527,7 +579,11 @@ - - - - - - - - - - - - - - @@ -971,6 +951,38 @@ + + + + + + + + + + + + + + - - - - - - + + + + + + localhost @@ -1214,7 +1226,7 @@ @@ -1261,126 +1273,134 @@ - + - - - - - - - - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - + + - + - + - + - + - - - - - - - - + - + - + - + - + - + - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/translator/src/org/jetbrains/k2js/declarations/Declarations.java b/translator/src/org/jetbrains/k2js/declarations/Declarations.java index a5ad56722e4..e688362c7ba 100644 --- a/translator/src/org/jetbrains/k2js/declarations/Declarations.java +++ b/translator/src/org/jetbrains/k2js/declarations/Declarations.java @@ -41,11 +41,10 @@ public final class Declarations { //TODO: provide a mechanism to do intrinsics public void extractStandardLibrary(@NotNull JetStandardLibrary standardLibrary) { DeclarationVisitor visitor = new DeclarationVisitor(this); -// for (DeclarationDescriptor descriptor : -// standardLibrary.getLibraryScope().getAllDescriptors()) { -// descriptor.accept(visitor, rootScope); -// } - // standardLibrary.getArray().accept(visitor, rootScope); + for (DeclarationDescriptor descriptor : + standardLibrary.getLibraryScope().getAllDescriptors()) { + descriptor.accept(visitor, DeclarationContext.rootContext(rootScope, null)); + } } @NotNull diff --git a/translator/src/org/jetbrains/k2js/intrinsic/BinaryOperationIntrinsic.java b/translator/src/org/jetbrains/k2js/intrinsic/BinaryOperationIntrinsic.java new file mode 100644 index 00000000000..175db4de3d9 --- /dev/null +++ b/translator/src/org/jetbrains/k2js/intrinsic/BinaryOperationIntrinsic.java @@ -0,0 +1,31 @@ +package org.jetbrains.k2js.intrinsic; + +import com.google.dart.compiler.backend.js.ast.JsExpression; +import com.google.dart.compiler.backend.js.ast.JsThisRef; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.psi.JetExpression; + +import java.util.List; + +/** + * @author Talanov Pavel + */ +public final class BinaryOperationIntrinsic implements Intrinsic { + @NotNull + @Override + public JsExpression apply(@NotNull FunctionDescriptor descriptor, @NotNull JetExpression receiver, + @NotNull List arguments) { + //TODO: implement +// +// JetToken correspondingToken = OperatorConventions.getTokenForMethodName(descriptor.getName()); +// JsBinaryOperator operator = OperatorTable.getBinaryOperator(correspondingToken); +// +// assert arguments.size() == 1 : "Binary operations expects 2 arguments."; +// JsExpression argument = arguments.get(0); +// assert argument != null; +// +// return new JsBinaryOperation(operator, receiver, argument); + return new JsThisRef(); + } +} diff --git a/translator/src/org/jetbrains/k2js/intrinsic/Intrinsic.java b/translator/src/org/jetbrains/k2js/intrinsic/Intrinsic.java new file mode 100644 index 00000000000..a35a033bb77 --- /dev/null +++ b/translator/src/org/jetbrains/k2js/intrinsic/Intrinsic.java @@ -0,0 +1,19 @@ +package org.jetbrains.k2js.intrinsic; + +import com.google.dart.compiler.backend.js.ast.JsExpression; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.psi.JetExpression; + +import java.util.List; + +/** + * @author Talanov Pavel + */ +public interface Intrinsic { + + @NotNull + JsExpression apply(@NotNull FunctionDescriptor descriptor, @NotNull JetExpression receiver, + @NotNull List arguments); + +} diff --git a/translator/src/org/jetbrains/k2js/intrinsic/IntrinsicDeclarationVisitor.java b/translator/src/org/jetbrains/k2js/intrinsic/IntrinsicDeclarationVisitor.java new file mode 100644 index 00000000000..c0a20fd12fa --- /dev/null +++ b/translator/src/org/jetbrains/k2js/intrinsic/IntrinsicDeclarationVisitor.java @@ -0,0 +1,36 @@ +package org.jetbrains.k2js.intrinsic; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; + +/** + * @author Talanov Pavel + */ +public final class IntrinsicDeclarationVisitor extends DeclarationDescriptorVisitor { + + @NotNull + private final Intrinsics intrinsics; + + /*package*/ IntrinsicDeclarationVisitor(@NotNull Intrinsics intrinsics) { + this.intrinsics = intrinsics; + } + + @Override + public Void visitClassDescriptor(@NotNull ClassDescriptor descriptor, @Nullable Void nothing) { + for (DeclarationDescriptor memberDescriptor : + descriptor.getDefaultType().getMemberScope().getAllDescriptors()) { + memberDescriptor.accept(this, null); + } + return null; + } + + @Override + public Void visitFunctionDescriptor(@NotNull FunctionDescriptor descriptor, @Nullable Void nothing) { + intrinsics.declareIntrinsic(descriptor); + return null; + } +} diff --git a/translator/src/org/jetbrains/k2js/intrinsic/Intrinsics.java b/translator/src/org/jetbrains/k2js/intrinsic/Intrinsics.java new file mode 100644 index 00000000000..ca89b74c42d --- /dev/null +++ b/translator/src/org/jetbrains/k2js/intrinsic/Intrinsics.java @@ -0,0 +1,81 @@ +package org.jetbrains.k2js.intrinsic; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.types.JetStandardLibrary; +import org.jetbrains.jet.lang.types.expressions.OperatorConventions; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author Talanov Pavel + */ +public final class Intrinsics { + + @NotNull + private final Map descriptorToIntrinsicMap = + new HashMap(); + + public static Intrinsics standardLibraryIntrinsics(@NotNull JetStandardLibrary library) { + return new Intrinsics(library); + } + + private Intrinsics(@NotNull JetStandardLibrary library) { + IntrinsicDeclarationVisitor visitor = new IntrinsicDeclarationVisitor(this); + for (DeclarationDescriptor descriptor : library.getLibraryScope().getAllDescriptors()) { + descriptor.accept(visitor, null); + } + } + + /*package*/ void declareIntrinsic(@NotNull FunctionDescriptor descriptor) { + //TODO: this is a hack +// addBinaryIntrinsics(descriptor); +// addUnaryIntrinsics(descriptor); +// addAssignmentIntrinsics(descriptor); +// addEqualsIntrinsics(descriptor); + BinaryOperationIntrinsic binaryOperationIntrinsic = new BinaryOperationIntrinsic(); + descriptorToIntrinsicMap.put(descriptor, binaryOperationIntrinsic); + } + + private void addEqualsIntrinsics(FunctionDescriptor descriptor) { + BinaryOperationIntrinsic binaryOperationIntrinsic = new BinaryOperationIntrinsic(); + String functionName = descriptor.getName(); + if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsValue(functionName)) { + descriptorToIntrinsicMap.put(descriptor, binaryOperationIntrinsic); + } + } + + private void addUnaryIntrinsics(@NotNull FunctionDescriptor descriptor) { + BinaryOperationIntrinsic binaryOperationIntrinsic = new BinaryOperationIntrinsic(); + String functionName = descriptor.getName(); + if (OperatorConventions.UNARY_OPERATION_NAMES.containsValue(functionName)) { + descriptorToIntrinsicMap.put(descriptor, binaryOperationIntrinsic); + } + } + + private void addBinaryIntrinsics(@NotNull FunctionDescriptor descriptor) { + String functionName = descriptor.getName(); + if (OperatorConventions.BINARY_OPERATION_NAMES.containsValue(functionName)) { + BinaryOperationIntrinsic binaryOperationIntrinsic = new BinaryOperationIntrinsic(); + descriptorToIntrinsicMap.put(descriptor, binaryOperationIntrinsic); + } + } + + private void addAssignmentIntrinsics(@NotNull FunctionDescriptor descriptor) { + String functionName = descriptor.getName(); + if (OperatorConventions.ASSIGNMENT_OPERATIONS.containsValue(functionName)) { + BinaryOperationIntrinsic binaryOperationIntrinsic = new BinaryOperationIntrinsic(); + descriptorToIntrinsicMap.put(descriptor, binaryOperationIntrinsic); + } + } + + public boolean isIntrinsic(@NotNull DeclarationDescriptor descriptor) { + if (descriptor instanceof FunctionDescriptor) { + FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor; + return descriptorToIntrinsicMap.containsKey(functionDescriptor); + } + return false; + } +} diff --git a/translator/src/org/jetbrains/k2js/translate/declaration/ClassTranslator.java b/translator/src/org/jetbrains/k2js/translate/declaration/ClassTranslator.java index f896f3aa367..f6e9ae273fd 100644 --- a/translator/src/org/jetbrains/k2js/translate/declaration/ClassTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/declaration/ClassTranslator.java @@ -100,7 +100,7 @@ public final class ClassTranslator extends AbstractTranslator { @NotNull private JsNameRef getClassReference(@NotNull ClassDescriptor superClassDescriptor) { //TODO we actually know that in current implementation superclass must have an alias but - // if future it might change + // in future it might change return context().aliaser().getAliasForDeclaration(superClassDescriptor); } diff --git a/translator/src/org/jetbrains/k2js/translate/expression/ExpressionVisitor.java b/translator/src/org/jetbrains/k2js/translate/expression/ExpressionVisitor.java index c1dc9fdf156..e7b2fc45ae5 100644 --- a/translator/src/org/jetbrains/k2js/translate/expression/ExpressionVisitor.java +++ b/translator/src/org/jetbrains/k2js/translate/expression/ExpressionVisitor.java @@ -57,7 +57,6 @@ public final class ExpressionVisitor extends TranslatorVisitor { public JsNode visitBlockExpression(@NotNull JetBlockExpression jetBlock, @NotNull TranslationContext context) { List statements = jetBlock.getStatements(); JsBlock jsBlock = new JsBlock(); - ; for (JetElement statement : statements) { assert statement instanceof JetExpression : "Elements in JetBlockExpression " + "should be of type JetExpression"; diff --git a/translator/src/org/jetbrains/k2js/translate/expression/FunctionTranslator.java b/translator/src/org/jetbrains/k2js/translate/expression/FunctionTranslator.java index 51e2c4418ee..258aec028aa 100644 --- a/translator/src/org/jetbrains/k2js/translate/expression/FunctionTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/expression/FunctionTranslator.java @@ -45,6 +45,7 @@ public final class FunctionTranslator extends AbstractTranslator { //TODO: consider refactoring @NotNull public JsExpression translateAsLiteral() { + //TODO: provide a way not to pollute global namespace JsName aliasForThis = context().enclosingScope().declareName("that"); context().aliaser().setAliasForThis(aliasForThis); JsFunction function = generateFunctionObject(); diff --git a/translator/src/org/jetbrains/k2js/translate/expression/PatternTranslator.java b/translator/src/org/jetbrains/k2js/translate/expression/PatternTranslator.java index 84e7b4d4c5a..c3e87c624d7 100644 --- a/translator/src/org/jetbrains/k2js/translate/expression/PatternTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/expression/PatternTranslator.java @@ -2,7 +2,6 @@ package org.jetbrains.k2js.translate.expression; import com.google.dart.compiler.backend.js.ast.JsExpression; import com.google.dart.compiler.backend.js.ast.JsInvocation; -import com.google.dart.compiler.backend.js.ast.JsName; import com.google.dart.compiler.backend.js.ast.JsNameRef; import com.google.dart.compiler.util.AstUtil; import org.jetbrains.annotations.NotNull; @@ -96,9 +95,6 @@ public final class PatternTranslator extends AbstractTranslator { private JsNameRef getClassNameReferenceForTypeReference(@NotNull JetTypeReference typeReference) { ClassDescriptor referencedClass = BindingUtils.getClassDescriptorForTypeReference (context().bindingContext(), typeReference); - //TODO should reference class by full name here - JsName className = context().getNameForDescriptor(referencedClass); - assert TranslationUtils.hasQualifier(context(), referencedClass); return TranslationUtils.getQualifiedReference(context(), referencedClass); } diff --git a/translator/src/org/jetbrains/k2js/translate/general/GenerationState.java b/translator/src/org/jetbrains/k2js/translate/general/GenerationState.java index 8d0b90d216b..deeb8d17853 100644 --- a/translator/src/org/jetbrains/k2js/translate/general/GenerationState.java +++ b/translator/src/org/jetbrains/k2js/translate/general/GenerationState.java @@ -13,6 +13,7 @@ import org.jetbrains.k2js.translate.utils.BindingUtils; import java.util.List; +//TODO: rework this class and the outer API public final class GenerationState { @NotNull diff --git a/translator/src/org/jetbrains/k2js/translate/general/StaticContext.java b/translator/src/org/jetbrains/k2js/translate/general/StaticContext.java new file mode 100644 index 00000000000..ca8e3da92bf --- /dev/null +++ b/translator/src/org/jetbrains/k2js/translate/general/StaticContext.java @@ -0,0 +1,121 @@ +package org.jetbrains.k2js.translate.general; + +import com.google.dart.compiler.backend.js.ast.JsName; +import com.google.dart.compiler.backend.js.ast.JsProgram; +import com.google.dart.compiler.backend.js.ast.JsRootScope; +import com.google.dart.compiler.backend.js.ast.JsScope; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.psi.JetElement; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.types.JetStandardLibrary; +import org.jetbrains.k2js.declarations.Declarations; +import org.jetbrains.k2js.intrinsic.Intrinsics; +import org.jetbrains.k2js.translate.utils.Namer; + +public class StaticContext { + + public static StaticContext generateStaticContext(@NotNull JetStandardLibrary library, + @NotNull BindingContext bindingContext) { + JsProgram program = new JsProgram("main"); + JsRootScope rootScope = program.getRootScope(); + Namer namer = Namer.newInstance(rootScope); + Aliaser aliaser = Aliaser.aliasesForStandardClasses(library, namer); + Declarations declarations = Declarations.newInstance(rootScope); + Intrinsics intrinsics = Intrinsics.standardLibraryIntrinsics(library); + return new StaticContext(program, bindingContext, declarations, aliaser, namer, intrinsics); + } + + @NotNull + private final JsProgram program; + + @NotNull + public final BindingContext bindingContext; + + @NotNull + private final Declarations declarations; + + @NotNull + private final Aliaser aliaser; + + @NotNull + private final Namer namer; + + @NotNull + private final Intrinsics intrinsics; + + + private StaticContext(@NotNull JsProgram program, @NotNull BindingContext bindingContext, + @NotNull Declarations declarations, @NotNull Aliaser aliaser, + @NotNull Namer namer, @NotNull Intrinsics intrinsics) { + this.program = program; + this.bindingContext = bindingContext; + this.declarations = declarations; + this.aliaser = aliaser; + this.namer = namer; + this.intrinsics = intrinsics; + } + + @NotNull + public JsProgram getProgram() { + return program; + } + + @NotNull + public BindingContext getBindingContext() { + return bindingContext; + } + + @NotNull + public Declarations getDeclarations() { + return declarations; + } + + @NotNull + public Aliaser getAliaser() { + return aliaser; + } + + @NotNull + public Intrinsics getIntrinsics() { + return intrinsics; + } + + @NotNull + public Namer getNamer() { + return namer; + } + + @NotNull + public JsScope getScopeForDescriptor(@NotNull DeclarationDescriptor descriptor) { + return declarations.getScope(descriptor); + } + + @NotNull + public JsScope getScopeForElement(@NotNull JetElement element) { + DeclarationDescriptor descriptor = getDescriptorForElement(element); + return getScopeForDescriptor(descriptor); + } + + @NotNull + public JsName getNameForDescriptor(@NotNull DeclarationDescriptor descriptor) { + return declarations.getName(descriptor); + } + + @NotNull + public JsName getNameForElement(@NotNull JetElement element) { + DeclarationDescriptor descriptor = getDescriptorForElement(element); + return getNameForDescriptor(descriptor); + } + + @NotNull + DeclarationDescriptor getDescriptorForElement(@NotNull JetElement element) { + DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element); + assert descriptor != null : "Element should have a descriptor"; + return descriptor; + } + + public boolean isDeclared(@NotNull DeclarationDescriptor descriptor) { + return declarations.hasDeclaredName(descriptor); + } +} \ No newline at end of file diff --git a/translator/src/org/jetbrains/k2js/translate/general/Translation.java b/translator/src/org/jetbrains/k2js/translate/general/Translation.java index 50c052dc3a0..cbd681a2ef9 100644 --- a/translator/src/org/jetbrains/k2js/translate/general/Translation.java +++ b/translator/src/org/jetbrains/k2js/translate/general/Translation.java @@ -8,7 +8,6 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.types.JetStandardLibrary; -import org.jetbrains.k2js.declarations.Declarations; import org.jetbrains.k2js.translate.declaration.ClassTranslator; import org.jetbrains.k2js.translate.declaration.NamespaceTranslator; import org.jetbrains.k2js.translate.expression.ExpressionVisitor; @@ -56,17 +55,20 @@ public final class Translation { } @NotNull - static public JsExpression translateAsExpression(@NotNull JetExpression expression, @NotNull TranslationContext context) { + static public JsExpression translateAsExpression(@NotNull JetExpression expression, + @NotNull TranslationContext context) { return AstUtil.convertToExpression(translateExpression(expression, context)); } @NotNull - static public JsStatement translateAsStatement(@NotNull JetExpression expression, @NotNull TranslationContext context) { + static public JsStatement translateAsStatement(@NotNull JetExpression expression, + @NotNull TranslationContext context) { return AstUtil.convertToStatement(translateExpression(expression, context)); } @NotNull - static public JsNode translateWhenExpression(@NotNull JetWhenExpression expression, @NotNull TranslationContext context) { + static public JsNode translateWhenExpression(@NotNull JetWhenExpression expression, + @NotNull TranslationContext context) { return WhenTranslator.translateWhenExpression(expression, context); } @@ -84,16 +86,15 @@ public final class Translation { public static JsProgram generateAst(@NotNull BindingContext bindingContext, @NotNull JetNamespace namespace, @NotNull Project project) { - //TODO hardcoded - JsProgram result = new JsProgram("main"); + JetStandardLibrary standardLibrary = JetStandardLibrary.getJetStandardLibrary(project); NamespaceDescriptor descriptor = BindingUtils.getNamespaceDescriptor(bindingContext, namespace); - Declarations declarations = Declarations.newInstance(result.getRootScope()); - declarations.extractStandardLibrary(JetStandardLibrary.getJetStandardLibrary(project)); - declarations.extractDeclarations(descriptor); - JsBlock block = result.getFragmentBlock(0); - TranslationContext context = TranslationContext.rootContext(result, bindingContext, declarations, project); + StaticContext staticContext = StaticContext.generateStaticContext(standardLibrary, bindingContext); + staticContext.getDeclarations().extractStandardLibrary(standardLibrary); + staticContext.getDeclarations().extractDeclarations(descriptor); + JsBlock block = staticContext.getProgram().getFragmentBlock(0); + TranslationContext context = TranslationContext.rootContext(staticContext); block.addStatement(Translation.translateNamespace(namespace, context)); - return result; + return context.program(); } diff --git a/translator/src/org/jetbrains/k2js/translate/general/TranslationContext.java b/translator/src/org/jetbrains/k2js/translate/general/TranslationContext.java index 0acf98a3061..95e1d6f2deb 100644 --- a/translator/src/org/jetbrains/k2js/translate/general/TranslationContext.java +++ b/translator/src/org/jetbrains/k2js/translate/general/TranslationContext.java @@ -3,13 +3,12 @@ package org.jetbrains.k2js.translate.general; import com.google.dart.compiler.backend.js.ast.JsName; import com.google.dart.compiler.backend.js.ast.JsProgram; import com.google.dart.compiler.backend.js.ast.JsScope; -import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.types.JetStandardLibrary; import org.jetbrains.k2js.declarations.Declarations; +import org.jetbrains.k2js.intrinsic.Intrinsics; import org.jetbrains.k2js.translate.utils.BindingUtils; import org.jetbrains.k2js.translate.utils.Namer; @@ -18,7 +17,6 @@ import org.jetbrains.k2js.translate.utils.Namer; */ public final class TranslationContext { - // TODO: extract different parts of this classes into separate classes private static class Scopes { public Scopes(@NotNull JsScope enclosingScope, @NotNull JsScope functionScope, @NotNull JsScope namespaceScope) { this.enclosingScope = enclosingScope; @@ -35,72 +33,50 @@ public final class TranslationContext { } @NotNull - public static TranslationContext rootContext(@NotNull JsProgram program, @NotNull BindingContext bindingContext, - @NotNull Declarations extractor, @NotNull Project project) { - JsScope rootScope = program.getRootScope(); + public static TranslationContext rootContext(@NotNull StaticContext staticContext) { + JsScope rootScope = staticContext.getProgram().getRootScope(); Scopes scopes = new Scopes(rootScope, rootScope, rootScope); - Namer namer = Namer.newInstance(rootScope); - Aliaser aliaser = Aliaser.aliasesForStandardClasses - (JetStandardLibrary.getJetStandardLibrary(project), namer); - return new TranslationContext(program, bindingContext, - scopes, extractor, aliaser, namer); + return new TranslationContext(staticContext, scopes); } - @NotNull - private final JsProgram program; - @NotNull - private final BindingContext bindingContext; @NotNull private final Scopes scopes; @NotNull - private final Declarations declarations; - @NotNull - private final Aliaser aliaser; - @NotNull - private final Namer namer; + private final StaticContext staticContext; - private TranslationContext(@NotNull JsProgram program, - @NotNull BindingContext bindingContext, @NotNull Scopes scopes, - @NotNull Declarations declarations, @NotNull Aliaser aliaser, - @NotNull Namer namer) { - this.program = program; - this.bindingContext = bindingContext; + private TranslationContext(@NotNull StaticContext staticContext, @NotNull Scopes scopes) { this.scopes = scopes; - this.declarations = declarations; - this.aliaser = aliaser; - this.namer = namer; + this.staticContext = staticContext; } @NotNull public TranslationContext newNamespace(@NotNull JetNamespace declaration) { - return newNamespace(BindingUtils.getNamespaceDescriptor(bindingContext, declaration)); + return newNamespace(BindingUtils.getNamespaceDescriptor(staticContext.getBindingContext(), declaration)); } @NotNull public TranslationContext newNamespace(@NotNull NamespaceDescriptor descriptor) { - JsScope namespaceScope = declarations.getScope(descriptor); + JsScope namespaceScope = staticContext.getDeclarations().getScope(descriptor); Scopes newScopes = new Scopes(namespaceScope, namespaceScope, namespaceScope); - return new TranslationContext(program, bindingContext, newScopes, - declarations, aliaser, namer); + return new TranslationContext(staticContext, newScopes); } @NotNull public TranslationContext newClass(@NotNull JetClass declaration) { - return newClass(BindingUtils.getClassDescriptor(bindingContext, declaration)); + return newClass(BindingUtils.getClassDescriptor(staticContext.getBindingContext(), declaration)); } @NotNull public TranslationContext newClass(@NotNull ClassDescriptor descriptor) { - JsScope classScope = declarations.getScope(descriptor); + JsScope classScope = staticContext.getDeclarations().getScope(descriptor); Scopes newScopes = new Scopes(classScope, classScope, scopes.namespaceScope); - return new TranslationContext(program, bindingContext, - newScopes, declarations, aliaser, namer); + return new TranslationContext(staticContext, newScopes); } @NotNull public TranslationContext newPropertyAccess(@NotNull JetPropertyAccessor declaration) { - return newPropertyAccess(BindingUtils.getPropertyAccessorDescriptor(bindingContext, declaration)); + return newPropertyAccess(BindingUtils.getPropertyAccessorDescriptor(staticContext.getBindingContext(), declaration)); } @NotNull @@ -110,33 +86,31 @@ public final class TranslationContext { @NotNull public TranslationContext newFunctionDeclaration(@NotNull JetNamedFunction declaration) { - return newFunctionDeclaration(BindingUtils.getFunctionDescriptor(bindingContext, declaration)); + return newFunctionDeclaration(BindingUtils.getFunctionDescriptor(staticContext.getBindingContext(), declaration)); } @NotNull public TranslationContext newFunctionDeclaration(@NotNull FunctionDescriptor descriptor) { - JsScope functionScope = declarations.getScope(descriptor); + JsScope functionScope = staticContext.getDeclarations().getScope(descriptor); Scopes newScopes = new Scopes(functionScope, scopes.classScope, scopes.namespaceScope); - return new TranslationContext(program, bindingContext, - newScopes, declarations, aliaser, namer); + return new TranslationContext(staticContext, newScopes); } // Note: Should be used if and only if scope has no corresponding descriptor @NotNull public TranslationContext newEnclosingScope(@NotNull JsScope enclosingScope) { Scopes newScopes = new Scopes(enclosingScope, scopes.classScope, scopes.namespaceScope); - return new TranslationContext(program, bindingContext, - newScopes, declarations, aliaser, namer); + return new TranslationContext(staticContext, newScopes); } @NotNull public BindingContext bindingContext() { - return bindingContext; + return staticContext.getBindingContext(); } @NotNull public JsProgram program() { - return program; + return staticContext.getProgram(); } @NotNull @@ -157,49 +131,50 @@ public final class TranslationContext { @NotNull public JsScope getScopeForDescriptor(@NotNull DeclarationDescriptor descriptor) { - return declarations.getScope(descriptor); + return staticContext.getScopeForDescriptor(descriptor); } @NotNull public JsScope getScopeForElement(@NotNull JetElement element) { - DeclarationDescriptor descriptor = getDescriptorForElement(element); - return getScopeForDescriptor(descriptor); + return staticContext.getScopeForElement(element); } @NotNull public JsName getNameForDescriptor(@NotNull DeclarationDescriptor descriptor) { - return declarations.getName(descriptor); + return staticContext.getNameForDescriptor(descriptor); } @NotNull public JsName getNameForElement(@NotNull JetElement element) { - DeclarationDescriptor descriptor = getDescriptorForElement(element); - return getNameForDescriptor(descriptor); + return staticContext.getNameForElement(element); } @NotNull private DeclarationDescriptor getDescriptorForElement(@NotNull JetElement element) { - DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element); - assert descriptor != null : "Element should have a descriptor"; - return descriptor; + return staticContext.getDescriptorForElement(element); } public boolean isDeclared(@NotNull DeclarationDescriptor descriptor) { - return declarations.hasDeclaredName(descriptor); + return staticContext.isDeclared(descriptor); } @NotNull public Aliaser aliaser() { - return aliaser; + return staticContext.getAliaser(); } @NotNull public Namer namer() { - return namer; + return staticContext.getNamer(); } @NotNull public Declarations declarations() { - return declarations; + return staticContext.getDeclarations(); + } + + @NotNull + public Intrinsics intrinsics() { + return staticContext.getIntrinsics(); } } diff --git a/translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java b/translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java index f40d82b6259..d1ca016c8e9 100644 --- a/translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/operation/BinaryOperationTranslator.java @@ -61,9 +61,9 @@ public final class BinaryOperationTranslator extends OperationTranslator { private JsExpression asCompareToOverload() { JetToken operationToken = getOperationToken(); assert (OperatorConventions.COMPARISON_OPERATIONS.contains(operationToken)); - JsNumberLiteral zetoLiteral = program().getNumberLiteral(0); + JsNumberLiteral zeroLiteral = program().getNumberLiteral(0); JsBinaryOperator correspondingOperator = OperatorTable.getBinaryOperator(operationToken); - return new JsBinaryOperation(correspondingOperator, overloadedMethodInvocation(), zetoLiteral); + return new JsBinaryOperation(correspondingOperator, overloadedMethodInvocation(), zeroLiteral); } private boolean isOverloadedCall() { diff --git a/translator/src/org/jetbrains/k2js/translate/operation/OperationTranslator.java b/translator/src/org/jetbrains/k2js/translate/operation/OperationTranslator.java index 2c8c70e77d7..f4f2a507b8d 100644 --- a/translator/src/org/jetbrains/k2js/translate/operation/OperationTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/operation/OperationTranslator.java @@ -29,6 +29,9 @@ public class OperationTranslator extends AbstractTranslator { if (operationDescriptor == null) { return null; } + if (context().intrinsics().isIntrinsic(operationDescriptor)) { + return null; + } if (!context().isDeclared(operationDescriptor)) { return null; } diff --git a/translator/src/org/jetbrains/k2js/translate/operation/UnaryOperationTranslator.java b/translator/src/org/jetbrains/k2js/translate/operation/UnaryOperationTranslator.java index e17365555f6..82e7dda0992 100644 --- a/translator/src/org/jetbrains/k2js/translate/operation/UnaryOperationTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/operation/UnaryOperationTranslator.java @@ -107,7 +107,6 @@ public final class UnaryOperationTranslator extends OperationTranslator { return AstUtil.newSequence(t1.assignmentExpression(), t2.assignmentExpression(), methodCall, returnedValue); } - //TODO: should modify this for properties @NotNull private JsExpression variableReassignment(@NotNull JsExpression toCallMethodUpon) { if (isPropertyAccess) { diff --git a/translator/src/org/jetbrains/k2js/translate/reference/PropertyAccessTranslator.java b/translator/src/org/jetbrains/k2js/translate/reference/PropertyAccessTranslator.java index ee26e452d96..c4898b29a2f 100644 --- a/translator/src/org/jetbrains/k2js/translate/reference/PropertyAccessTranslator.java +++ b/translator/src/org/jetbrains/k2js/translate/reference/PropertyAccessTranslator.java @@ -23,7 +23,6 @@ import org.jetbrains.k2js.translate.utils.TranslationUtils; /** * @author Talanov Pavel */ -//TODO Refactor. public final class PropertyAccessTranslator extends AbstractTranslator { private static String MESSAGE = "Cannot be accessor call. Use canBeProperty*Call to ensure this method " + @@ -219,6 +218,15 @@ public final class PropertyAccessTranslator extends AbstractTranslator { @Nullable private JsName getNullableSetterName() { + PropertySetterDescriptor setter = getSetterDescriptor(); + + if (setter == null) return null; + + return context().getNameForDescriptor(setter); + } + + @Nullable + private PropertySetterDescriptor getSetterDescriptor() { PropertyDescriptor property = getNullablePropertyDescriptor(); if (property == null) { return null; @@ -227,7 +235,7 @@ public final class PropertyAccessTranslator extends AbstractTranslator { if (setter == null) { return null; } - return context().getNameForDescriptor(setter); + return setter; } @Nullable