diff --git a/ets2panda/BUILD.gn b/ets2panda/BUILD.gn index fa8e3f19192d3ac6868e418e5fce7111384a00c2..93991ef2453d110b36dd32ff57df99aa22653b76 100644 --- a/ets2panda/BUILD.gn +++ b/ets2panda/BUILD.gn @@ -251,6 +251,7 @@ libes2panda_sources = [ "ir/module/importNamespaceSpecifier.cpp", "ir/module/importSpecifier.cpp", "ir/opaqueTypeNode.cpp", + "ir/srcDump.cpp", "ir/statement.cpp", "ir/statements/assertStatement.cpp", "ir/statements/blockStatement.cpp", diff --git a/ets2panda/CMakeLists.txt b/ets2panda/CMakeLists.txt index b56057c82890a5021b0631b397af1d2db77e738f..fdf4814cf49f80641320b28a5e62966772013473 100644 --- a/ets2panda/CMakeLists.txt +++ b/ets2panda/CMakeLists.txt @@ -149,6 +149,7 @@ set(ES2PANDA_LIB_SRC compiler/lowering/ets/tupleLowering.cpp compiler/lowering/ets/unionLowering.cpp ir/astDump.cpp + ir/srcDump.cpp ir/astNode.cpp ir/irnode.cpp ir/typeNode.cpp diff --git a/ets2panda/compiler/lowering/phase.cpp b/ets2panda/compiler/lowering/phase.cpp index 67f22b81497fe22333814ea570df4cd8200c52c6..95a174afc58aa67ac235292dd8f6cbf820563b7f 100644 --- a/ets2panda/compiler/lowering/phase.cpp +++ b/ets2panda/compiler/lowering/phase.cpp @@ -113,10 +113,7 @@ bool Phase::Apply(public_lib::Context *ctx, parser::Program *program) return true; } - if (options->dump_before_phases.count(name) > 0) { - std::cout << "Before phase " << Name() << ":" << std::endl; - std::cout << program->Dump() << std::endl; - } + CheckOptionsBeforePhase(options, program, name); #ifndef NDEBUG if (!Precondition(ctx, program)) { @@ -129,10 +126,7 @@ bool Phase::Apply(public_lib::Context *ctx, parser::Program *program) return false; } - if (options->dump_after_phases.count(name) > 0) { - std::cout << "After phase " << Name() << ":" << std::endl; - std::cout << program->Dump() << std::endl; - } + CheckOptionsAfterPhase(options, program, name); #ifndef NDEBUG check_program(program); @@ -146,4 +140,34 @@ bool Phase::Apply(public_lib::Context *ctx, parser::Program *program) return true; } +void Phase::CheckOptionsBeforePhase(const CompilerOptions *options, const parser::Program *program, + const std::string &name) const +{ + if (options->dump_after_phases.count(name) > 0) { + std::cout << "After phase " << name << ":" << std::endl; + std::cout << program->Dump() << std::endl; + } + + if (options->dump_ets_src_after_phases.count(name) > 0) { + std::cout << "After phase " << name << " ets source" + << ":" << std::endl; + std::cout << program->Ast()->DumpEtsSrc() << std::endl; + } +} + +void Phase::CheckOptionsAfterPhase(const CompilerOptions *options, const parser::Program *program, + const std::string &name) const +{ + if (options->dump_after_phases.count(name) > 0) { + std::cout << "After phase " << name << ":" << std::endl; + std::cout << program->Dump() << std::endl; + } + + if (options->dump_ets_src_after_phases.count(name) > 0) { + std::cout << "After phase " << name << " ets source" + << ":" << std::endl; + std::cout << program->Ast()->DumpEtsSrc() << std::endl; + } +} + } // namespace panda::es2panda::compiler diff --git a/ets2panda/compiler/lowering/phase.h b/ets2panda/compiler/lowering/phase.h index 8052a9ab2d159c2438ad20a49c0462bac97a495d..9e2a381c149d5deec09974f65475f28edc75c361 100644 --- a/ets2panda/compiler/lowering/phase.h +++ b/ets2panda/compiler/lowering/phase.h @@ -39,6 +39,12 @@ public: { return true; } + +private: + void CheckOptionsBeforePhase(const CompilerOptions *options, const parser::Program *program, + const std::string &name) const; + void CheckOptionsAfterPhase(const CompilerOptions *options, const parser::Program *program, + const std::string &name) const; }; std::vector GetPhaseList(ScriptExtension ext); diff --git a/ets2panda/es2panda.h b/ets2panda/es2panda.h index 78ccfc73c5f7155ba8b911355e4e9e34d9f4a2ec..b2ed26077c54a9bd1cc05f3205122db3d8098ddf 100644 --- a/ets2panda/es2panda.h +++ b/ets2panda/es2panda.h @@ -104,7 +104,9 @@ struct CompilerOptions { std::vector plugins {}; std::unordered_set skip_phases {}; std::unordered_set dump_before_phases {}; + std::unordered_set dump_ets_src_before_phases {}; std::unordered_set dump_after_phases {}; + std::unordered_set dump_ets_src_after_phases {}; std::shared_ptr arkts_config {}; CompilationMode compilation_mode {}; // NOLINTEND(misc-non-private-member-variables-in-classes) diff --git a/ets2panda/ir/as/namedType.cpp b/ets2panda/ir/as/namedType.cpp index 1957c7a148cc2c3732419abbb46ea19bcc4ae699..8c1cd53504ad063655adc0294617d5ea63bfba34 100644 --- a/ets2panda/ir/as/namedType.cpp +++ b/ets2panda/ir/as/namedType.cpp @@ -21,6 +21,7 @@ #include "ir/expressions/identifier.h" #include "ir/ts/tsTypeParameterInstantiation.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void NamedType::TransformChildren(const NodeTransformer &cb) @@ -58,6 +59,11 @@ void NamedType::Dump(AstDumper *dumper) const {"isNullable", nullable_}}); } +void NamedType::Dump(SrcDumper *dumper) const +{ + dumper->Add("NamedType"); +} + void NamedType::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/as/namedType.h b/ets2panda/ir/as/namedType.h index 5c8259eb998df44427c6e06d268bb27bac78032e..f0da80b2a4dbf42d7e332fa23ddc144c84f771c0 100644 --- a/ets2panda/ir/as/namedType.h +++ b/ets2panda/ir/as/namedType.h @@ -59,6 +59,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; diff --git a/ets2panda/ir/as/prefixAssertionExpression.cpp b/ets2panda/ir/as/prefixAssertionExpression.cpp index 9d16342536c0d1d11ac42be1cedf12fe6d2d641c..e06f9058a6e81c556f013361eaf23c69eab2c447 100644 --- a/ets2panda/ir/as/prefixAssertionExpression.cpp +++ b/ets2panda/ir/as/prefixAssertionExpression.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" namespace panda::es2panda::ir { @@ -39,6 +40,11 @@ void PrefixAssertionExpression::Dump(AstDumper *dumper) const dumper->Add({{"type", "PrefixAssertionExpression"}, {"expression", expr_}, {"type", type_}}); } +void PrefixAssertionExpression::Dump(SrcDumper *dumper) const +{ + dumper->Add("PrefixAssertionExpression"); +} + void PrefixAssertionExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/as/prefixAssertionExpression.h b/ets2panda/ir/as/prefixAssertionExpression.h index 758df8b69864ad54f254bbaa85e4fa0b3bc957e9..63546010db665bab4aa344175c0bf7b8e81547b6 100644 --- a/ets2panda/ir/as/prefixAssertionExpression.h +++ b/ets2panda/ir/as/prefixAssertionExpression.h @@ -39,6 +39,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/astNode.cpp b/ets2panda/ir/astNode.cpp index 4687db69022050d5086d038a32b3b74175fdb737..19a80ab4ca51a4da7dcf9b9c95540cbb5dcee7ec 100644 --- a/ets2panda/ir/astNode.cpp +++ b/ets2panda/ir/astNode.cpp @@ -15,6 +15,7 @@ #include "astNode.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "typeNode.h" namespace panda::es2panda::ir { @@ -115,4 +116,10 @@ std::string AstNode::DumpJSON() const ir::AstDumper dumper {this}; return dumper.Str(); } + +std::string AstNode::DumpEtsSrc() const +{ + ir::SrcDumper dumper {this}; + return dumper.Str(); +} } // namespace panda::es2panda::ir diff --git a/ets2panda/ir/astNode.h b/ets2panda/ir/astNode.h index 9a30d7bb961d069a6375c232c325bc4db228d4dd..e6f7b47c0c498cde22588afed9ea9891f63e67b2 100644 --- a/ets2panda/ir/astNode.h +++ b/ets2panda/ir/astNode.h @@ -75,6 +75,7 @@ DEFINE_BITOPS(BoxingUnboxingFlags) // Forward declarations class AstDumper; class Expression; +class SrcDumper; class Statement; class ClassElement; @@ -478,8 +479,10 @@ public: AstNode *FindChild(const NodePredicate &cb) const; std::string DumpJSON() const; + std::string DumpEtsSrc() const; virtual void Dump(ir::AstDumper *dumper) const = 0; + virtual void Dump(ir::SrcDumper *dumper) const = 0; virtual void Compile([[maybe_unused]] compiler::PandaGen *pg) const = 0; virtual void Compile([[maybe_unused]] compiler::ETSGen *etsg) const {}; virtual checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) = 0; diff --git a/ets2panda/ir/base/catchClause.cpp b/ets2panda/ir/base/catchClause.cpp index feee7e595a855d62d2888410c7a4e973fda74216..da8ceb1c5523740b45c1f59f89b9f9b0db78c0f6 100644 --- a/ets2panda/ir/base/catchClause.cpp +++ b/ets2panda/ir/base/catchClause.cpp @@ -19,6 +19,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" #include "ir/statements/blockStatement.h" @@ -46,6 +47,22 @@ void CatchClause::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "CatchClause"}, {"body", body_}, {"param", AstDumper::Nullish(param_)}}); } +void CatchClause::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(body_ != nullptr); + dumper->Add("("); + if (param_ != nullptr) { + param_->Dump(dumper); + } + dumper->Add(") {"); + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + dumper->Add("}"); +} + bool CatchClause::IsDefaultCatchClause() const { return param_->AsIdentifier()->TypeAnnotation() == nullptr; diff --git a/ets2panda/ir/base/catchClause.h b/ets2panda/ir/base/catchClause.h index 22fff21e34e0fece5a216b438fa19e8dbcdac51a..0a4032356a9850ff592ef95da0d871263e5848eb 100644 --- a/ets2panda/ir/base/catchClause.h +++ b/ets2panda/ir/base/catchClause.h @@ -69,6 +69,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/classDefinition.cpp b/ets2panda/ir/base/classDefinition.cpp index 31520c1ffd1097eb9e0e568d5258279d52443180..86458df8520e5f3404f8339e5b9d1a863bb8d4c6 100644 --- a/ets2panda/ir/base/classDefinition.cpp +++ b/ets2panda/ir/base/classDefinition.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/classStaticBlock.h" #include "ir/base/methodDefinition.h" #include "ir/base/scriptFunction.h" @@ -130,6 +131,62 @@ void ClassDefinition::Dump(ir::AstDumper *dumper) const {"body", body_, prop_filter}}); } +void ClassDefinition::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(ident_ != nullptr); + + if (IsExtern()) { + dumper->Add("extern "); + } + + if (IsFinal()) { + dumper->Add("final "); + } + + if (IsAbstract()) { + dumper->Add("abstract "); + } + + dumper->Add("class "); + ident_->Dump(dumper); + + if (type_params_ != nullptr) { + dumper->Add("<"); + type_params_->Dump(dumper); + dumper->Add("> "); + } + + if (super_class_ != nullptr) { + dumper->Add(" extends "); + super_class_->Dump(dumper); + } + + if (!implements_.empty()) { + dumper->Add(" implements "); + for (auto interface : implements_) { + interface->Dump(dumper); + if (interface != implements_.back()) { + dumper->Add(", "); + } + } + } + + dumper->Add(" {"); + if (!body_.empty()) { + dumper->IncrIndent(); + dumper->Endl(); + for (auto elem : body_) { + elem->Dump(dumper); + if (elem == body_.back()) { + dumper->DecrIndent(); + } + dumper->Endl(); + } + } + dumper->Add("}"); + dumper->Endl(); +} + void ClassDefinition::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/classDefinition.h b/ets2panda/ir/base/classDefinition.h index f0fc0cebc39f7910f4c56a2658ee2921c3f9877f..e992e96ba135e72ebb5c72d7427f618a6a1e6d4c 100644 --- a/ets2panda/ir/base/classDefinition.h +++ b/ets2panda/ir/base/classDefinition.h @@ -275,7 +275,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/classProperty.cpp b/ets2panda/ir/base/classProperty.cpp index 26e1c96ed9b4ba24e57a03da0734685e9812fa6e..86699fdb3908d27de28517e4fee0b2868769acf6 100644 --- a/ets2panda/ir/base/classProperty.cpp +++ b/ets2panda/ir/base/classProperty.cpp @@ -21,6 +21,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/decorator.h" #include "ir/typeNode.h" #include "ir/expression.h" @@ -78,6 +79,43 @@ void ClassProperty::Dump(ir::AstDumper *dumper) const {"decorators", decorators_}}); } +void ClassProperty::Dump(ir::SrcDumper *dumper) const +{ + if (IsPrivate()) { + dumper->Add("private "); + } else if (IsProtected()) { + dumper->Add("protected "); + } else if (IsInternal()) { + dumper->Add("internal "); + } else { + dumper->Add("public "); + } + + if (IsStatic()) { + dumper->Add("static "); + } + + if (IsReadonly()) { + dumper->Add("readonly "); + } + + if (key_ != nullptr) { + key_->Dump(dumper); + } + + if (type_annotation_ != nullptr) { + dumper->Add(": "); + type_annotation_->Dump(dumper); + } + + if (value_ != nullptr) { + dumper->Add(" = "); + value_->Dump(dumper); + } + + dumper->Add(";"); +} + void ClassProperty::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/classProperty.h b/ets2panda/ir/base/classProperty.h index c9e7ae4b9155e27190373811d4029f79db8a3c95..474cd9694367a43e3b2b783ab9f142a6504e0667 100644 --- a/ets2panda/ir/base/classProperty.h +++ b/ets2panda/ir/base/classProperty.h @@ -58,7 +58,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/classStaticBlock.cpp b/ets2panda/ir/base/classStaticBlock.cpp index 4f0b307bbbcdb48f605a2a43a3099db54e0968ba..db53d66665b5e6bdb9815033de16e51a7c5f72b7 100644 --- a/ets2panda/ir/base/classStaticBlock.cpp +++ b/ets2panda/ir/base/classStaticBlock.cpp @@ -21,6 +21,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/decorator.h" #include "ir/base/scriptFunction.h" #include "ir/expression.h" @@ -46,6 +47,11 @@ void ClassStaticBlock::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ClassStaticBlock"}, {"value", value_}}); } +void ClassStaticBlock::Dump([[maybe_unused]] ir::SrcDumper *dumper) const +{ + // NOTE(nsizov): we don't want to show this node +} + void ClassStaticBlock::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/classStaticBlock.h b/ets2panda/ir/base/classStaticBlock.h index 89edc771a7eeb0dd5e676e0294b679f90fbfc764..7debb7fab878e8b1a6668a8f264d3a2ffa8b5a77 100644 --- a/ets2panda/ir/base/classStaticBlock.h +++ b/ets2panda/ir/base/classStaticBlock.h @@ -40,6 +40,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/decorator.cpp b/ets2panda/ir/base/decorator.cpp index beb884f79b09a942806568245b84a242d24ee780..eed3b5f6db795245ea5de04beba6a767083be7d1 100644 --- a/ets2panda/ir/base/decorator.cpp +++ b/ets2panda/ir/base/decorator.cpp @@ -18,6 +18,7 @@ #include "es2panda.h" #include "ir/expression.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/ETSchecker.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" @@ -39,6 +40,11 @@ void Decorator::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "Decorator"}, {"expression", expr_}}); } +void Decorator::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("Decorator"); +} + void Decorator::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/decorator.h b/ets2panda/ir/base/decorator.h index 303ee9f3546466cd1afcea1f960575f9b121efa0..dfbcc9027c1a169d64f2a3ca4333b90588b76964 100644 --- a/ets2panda/ir/base/decorator.h +++ b/ets2panda/ir/base/decorator.h @@ -42,6 +42,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/metaProperty.cpp b/ets2panda/ir/base/metaProperty.cpp index ed43fa1e0c5019d3e1fdc6f123eb67d6f794de51..a5208db90f2428856a38f8611feab9b44c39c97d 100644 --- a/ets2panda/ir/base/metaProperty.cpp +++ b/ets2panda/ir/base/metaProperty.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void MetaProperty::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -49,6 +51,11 @@ void MetaProperty::Compile(compiler::PandaGen *pg) const pg->GetAstCompiler()->Compile(this); } +void MetaProperty::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("MetaProperty"); +} + void MetaProperty::Compile(compiler::ETSGen *etsg) const { etsg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/metaProperty.h b/ets2panda/ir/base/metaProperty.h index 0fd279f9908a98c8611a935b6ee9b4c24abcf9f7..c5eb1bb8448c390cfcb2393bddb5107357585de5 100644 --- a/ets2panda/ir/base/metaProperty.h +++ b/ets2panda/ir/base/metaProperty.h @@ -48,6 +48,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/methodDefinition.cpp b/ets2panda/ir/base/methodDefinition.cpp index 0f261bdc94ac50e061e07d879fe216ecdb420c28..149db9d9b8a5b14121f761a15fff78a5262b95ba 100644 --- a/ets2panda/ir/base/methodDefinition.cpp +++ b/ets2panda/ir/base/methodDefinition.cpp @@ -19,6 +19,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { @@ -120,6 +122,56 @@ void MethodDefinition::Dump(ir::AstDumper *dumper) const {"decorators", decorators_}}); } +void MethodDefinition::Dump(ir::SrcDumper *dumper) const +{ + for (auto method : overloads_) { + method->Dump(dumper); + dumper->Endl(); + } + + if (IsPrivate()) { + dumper->Add("private "); + } else if (IsProtected()) { + dumper->Add("protected "); + } else if (IsInternal()) { + dumper->Add("internal "); + } else { + dumper->Add("public "); + } + + if (IsStatic()) { + dumper->Add("static "); + } + + if (IsAbstract()) { + dumper->Add("abstract "); + } + + if (IsFinal()) { + dumper->Add("final "); + } + + if (IsNative()) { + dumper->Add("native "); + } + + if (IsAsync()) { + dumper->Add("async "); + } + + if (IsOverride()) { + dumper->Add("override "); + } + + if (key_ != nullptr) { + key_->Dump(dumper); + } + + if (value_ != nullptr) { + value_->Dump(dumper); + } +} + void MethodDefinition::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/methodDefinition.h b/ets2panda/ir/base/methodDefinition.h index 8791bed9a38375cc5da38e01ad50f41576005ac7..5221b451fe85106693df0db9bcca360cb0d74eed 100644 --- a/ets2panda/ir/base/methodDefinition.h +++ b/ets2panda/ir/base/methodDefinition.h @@ -111,6 +111,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/property.cpp b/ets2panda/ir/base/property.cpp index 962be16443769caee63d58314ed3f6ee1164c249..113ae62241a34975ed7cacc0fd1b5bd1fdc12b43 100644 --- a/ets2panda/ir/base/property.cpp +++ b/ets2panda/ir/base/property.cpp @@ -19,6 +19,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { Property::Property([[maybe_unused]] Tag const tag, Property const &other, Expression *const key, @@ -177,6 +179,11 @@ void Property::Compile(compiler::ETSGen *etsg) const etsg->GetAstCompiler()->Compile(this); } +void Property::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("Property"); +} + checker::Type *Property::Check(checker::TSChecker *checker) { return checker->GetAnalyzer()->Check(this); diff --git a/ets2panda/ir/base/property.h b/ets2panda/ir/base/property.h index cb9f1636a0dfcc2c6dcef12671c06936895c2861..f69086b21f04cbed9977ea9b10e66ba834ff5ee8 100644 --- a/ets2panda/ir/base/property.h +++ b/ets2panda/ir/base/property.h @@ -111,6 +111,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/scriptFunction.cpp b/ets2panda/ir/base/scriptFunction.cpp index b9224670f5df2936269dbce0af8c28c87e701cc3..2c6753db0fa9925dd9dd3c8464179ef710efd385 100644 --- a/ets2panda/ir/base/scriptFunction.cpp +++ b/ets2panda/ir/base/scriptFunction.cpp @@ -19,6 +19,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { @@ -79,6 +81,49 @@ void ScriptFunction::Dump(ir::AstDumper *dumper) const } } +void ScriptFunction::Dump(ir::SrcDumper *dumper) const +{ + if (TypeParams() != nullptr) { + TypeParams()->Dump(dumper); + } + dumper->Add("("); + for (auto param : Params()) { + param->Dump(dumper); + if (param != Params().back()) { + dumper->Add(", "); + } + } + dumper->Add(")"); + if (ReturnTypeAnnotation() != nullptr) { + dumper->Add(": "); + ReturnTypeAnnotation()->Dump(dumper); + } + + if (IsThrowing()) { + dumper->Add(" throws"); + } + + if (HasBody()) { + if (body_->IsBlockStatement()) { + dumper->Add(" {"); + if (!body_->AsBlockStatement()->Statements().empty()) { + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("}"); + } else { + dumper->Add(" "); + body_->Dump(dumper); + } + } + if (!IsArrow()) { + dumper->Endl(); + } +} + void ScriptFunction::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/scriptFunction.h b/ets2panda/ir/base/scriptFunction.h index a037ff3afd53799ec07ef1e5e86eca856f27410e..f93616a1854c5e05b314b4589f7941f56f0b7e52 100644 --- a/ets2panda/ir/base/scriptFunction.h +++ b/ets2panda/ir/base/scriptFunction.h @@ -300,6 +300,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/spreadElement.cpp b/ets2panda/ir/base/spreadElement.cpp index aa6719ad4d18c89d49b5e30816b30e3e2143af4d..6dc6d00c601d3ca943c5a33361796667e059f88f 100644 --- a/ets2panda/ir/base/spreadElement.cpp +++ b/ets2panda/ir/base/spreadElement.cpp @@ -20,6 +20,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/decorator.h" #include "ir/typeNode.h" #include "ir/expressions/arrayExpression.h" @@ -140,6 +141,17 @@ void SpreadElement::Dump(ir::AstDumper *dumper) const {"typeAnnotation", AstDumper::Optional(TypeAnnotation())}}); } +void SpreadElement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("..."); + argument_->Dump(dumper); + auto type = TypeAnnotation(); + if (type != nullptr) { + dumper->Add(": "); + type->Dump(dumper); + } +} + void SpreadElement::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/spreadElement.h b/ets2panda/ir/base/spreadElement.h index 6e507264b332030f2fda9160ae1e311297a1c86a..bd484b6a0f960fc85af61006d1763151934cadfd 100644 --- a/ets2panda/ir/base/spreadElement.h +++ b/ets2panda/ir/base/spreadElement.h @@ -87,6 +87,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/templateElement.cpp b/ets2panda/ir/base/templateElement.cpp index f77f0237072aa10032568825d48f6b597cb03ab9..8816ba413cc58502d302ef49f5cb7e747013707e 100644 --- a/ets2panda/ir/base/templateElement.cpp +++ b/ets2panda/ir/base/templateElement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TemplateElement::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -31,6 +33,11 @@ void TemplateElement::Dump(ir::AstDumper *dumper) const }); } +void TemplateElement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TemplateElement"); +} + void TemplateElement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/templateElement.h b/ets2panda/ir/base/templateElement.h index 320770290d8a3f8429aa4480039661e7a2becc38..85154cdd14255dc18b8e3572d3d5ba44e9bac7aa 100644 --- a/ets2panda/ir/base/templateElement.h +++ b/ets2panda/ir/base/templateElement.h @@ -50,6 +50,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/tsIndexSignature.cpp b/ets2panda/ir/base/tsIndexSignature.cpp index 2bea99f714334c9e2337bd36192b2f155d89129c..f48774bd90b1b6601153c399bb9e5b9992083dd7 100644 --- a/ets2panda/ir/base/tsIndexSignature.cpp +++ b/ets2panda/ir/base/tsIndexSignature.cpp @@ -14,7 +14,8 @@ */ #include "tsIndexSignature.h" - +#include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" @@ -46,6 +47,11 @@ void TSIndexSignature::Dump(ir::AstDumper *dumper) const {"readonly", readonly_}}); } +void TSIndexSignature::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSIndexSignature"); +} + void TSIndexSignature::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/tsIndexSignature.h b/ets2panda/ir/base/tsIndexSignature.h index 4c9fd1ae28fdde51b6572adbb0f94b7ffdf402a9..d63443ec4db23cc73f78e3701b28f834415bffe1 100644 --- a/ets2panda/ir/base/tsIndexSignature.h +++ b/ets2panda/ir/base/tsIndexSignature.h @@ -67,6 +67,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/tsMethodSignature.cpp b/ets2panda/ir/base/tsMethodSignature.cpp index ab3eda45912a7250d1c4a6685dc5dc5199ac1505..11d32a2b4b4def7798c3b533ff3e89b3cf11d69d 100644 --- a/ets2panda/ir/base/tsMethodSignature.cpp +++ b/ets2panda/ir/base/tsMethodSignature.cpp @@ -14,7 +14,8 @@ */ #include "tsMethodSignature.h" - +#include "ir/astDump.h" +#include "ir/srcDump.h" #include "varbinder/scope.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" @@ -44,6 +45,11 @@ void TSMethodSignature::Dump(ir::AstDumper *dumper) const {"typeAnnotation", AstDumper::Optional(ReturnTypeAnnotation())}}); } +void TSMethodSignature::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSMethodSignature"); +} + void TSMethodSignature::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/tsMethodSignature.h b/ets2panda/ir/base/tsMethodSignature.h index fdc102d8bd4c096c072d03408e67dbd77e175504..369e482605adb250687b45316884985b85bee92f 100644 --- a/ets2panda/ir/base/tsMethodSignature.h +++ b/ets2panda/ir/base/tsMethodSignature.h @@ -111,6 +111,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/tsPropertySignature.cpp b/ets2panda/ir/base/tsPropertySignature.cpp index ee863b4b7c55c56b1d8f9cbd01cfef6206233a21..e055f5d9474748ddc6bb2857ac7943bacd51b991 100644 --- a/ets2panda/ir/base/tsPropertySignature.cpp +++ b/ets2panda/ir/base/tsPropertySignature.cpp @@ -14,7 +14,8 @@ */ #include "tsPropertySignature.h" - +#include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" @@ -48,6 +49,11 @@ void TSPropertySignature::Dump(ir::AstDumper *dumper) const {"typeAnnotation", AstDumper::Optional(TypeAnnotation())}}); } +void TSPropertySignature::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSPropertySignature"); +} + void TSPropertySignature::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/tsPropertySignature.h b/ets2panda/ir/base/tsPropertySignature.h index 02768c8d69eb6cf90cd157a78c0d186330ea08b6..4a462391d5bc186d83c14f36061c6ee2dbc84d8a 100644 --- a/ets2panda/ir/base/tsPropertySignature.h +++ b/ets2panda/ir/base/tsPropertySignature.h @@ -71,6 +71,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/base/tsSignatureDeclaration.cpp b/ets2panda/ir/base/tsSignatureDeclaration.cpp index 50825acdf8b86de7b3bae756f4e63179f3682646..cafb5a243f7c8366ccc976deeade245f8a5ca229 100644 --- a/ets2panda/ir/base/tsSignatureDeclaration.cpp +++ b/ets2panda/ir/base/tsSignatureDeclaration.cpp @@ -20,6 +20,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSSignatureDeclaration::TransformChildren(const NodeTransformer &cb) @@ -42,6 +44,11 @@ void TSSignatureDeclaration::Dump(ir::AstDumper *dumper) const {"returnType", AstDumper::Optional(ReturnTypeAnnotation())}}); } +void TSSignatureDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSSignatureDeclaration"); +} + void TSSignatureDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/base/tsSignatureDeclaration.h b/ets2panda/ir/base/tsSignatureDeclaration.h index b24d0abbe52b2658405094c59d65291d5f44f43d..caeeac2d2eb95fc344a8804bce98ac6bd6b8b7a1 100644 --- a/ets2panda/ir/base/tsSignatureDeclaration.h +++ b/ets2panda/ir/base/tsSignatureDeclaration.h @@ -93,7 +93,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsClassLiteral.cpp b/ets2panda/ir/ets/etsClassLiteral.cpp index 0168b7ddaf914abd097dc0ef03156e95ea638138..ad0eabe30565db726b6ce609ef4152c5157c70ad 100644 --- a/ets2panda/ir/ets/etsClassLiteral.cpp +++ b/ets2panda/ir/ets/etsClassLiteral.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSClassLiteral::TransformChildren(const NodeTransformer &cb) @@ -36,6 +37,11 @@ void ETSClassLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ETSClassLiteral"}}); } +void ETSClassLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ETSClassLiteral"); +} + void ETSClassLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsClassLiteral.h b/ets2panda/ir/ets/etsClassLiteral.h index e9262b2a6d7a3c22a2ad270eaa7475624af73089..592f3536fdab61e8af1a6f23c36c7db931883e49 100644 --- a/ets2panda/ir/ets/etsClassLiteral.h +++ b/ets2panda/ir/ets/etsClassLiteral.h @@ -48,6 +48,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsFunctionType.cpp b/ets2panda/ir/ets/etsFunctionType.cpp index adeff5d2b2325c10fc6283455b4d82fccdcde2ef..0c6844b0a15591b4f94391cc52e7c5587368af60 100644 --- a/ets2panda/ir/ets/etsFunctionType.cpp +++ b/ets2panda/ir/ets/etsFunctionType.cpp @@ -20,6 +20,8 @@ #include "checker/ETSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSFunctionType::TransformChildren(const NodeTransformer &cb) @@ -44,6 +46,27 @@ void ETSFunctionType::Dump(ir::AstDumper *dumper) const } } +void ETSFunctionType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("("); + for (auto *param : Params()) { + param->Dump(dumper); + if (param != Params().back()) { + dumper->Add(", "); + } + } + dumper->Add(")"); + + if (TypeParams() != nullptr) { + TypeParams()->Dump(dumper); + } + + if (ReturnType() != nullptr) { + dumper->Add("=> "); + ReturnType()->Dump(dumper); + } +} + void ETSFunctionType::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsFunctionType.h b/ets2panda/ir/ets/etsFunctionType.h index ca70d67077776efe362c8a3bf3ba1446fcf7c1d0..f52f97b5925d8859ef690eb36f2b0e359e5efb13 100644 --- a/ets2panda/ir/ets/etsFunctionType.h +++ b/ets2panda/ir/ets/etsFunctionType.h @@ -96,6 +96,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsLaunchExpression.cpp b/ets2panda/ir/ets/etsLaunchExpression.cpp index 8c006c458827173b3aa9eca42808bcf041167b9b..a492c7c3f23c6b867d27358dcac6bb5403e62d73 100644 --- a/ets2panda/ir/ets/etsLaunchExpression.cpp +++ b/ets2panda/ir/ets/etsLaunchExpression.cpp @@ -19,6 +19,8 @@ #include "compiler/core/ETSGen.h" #include "checker/ETSchecker.h" #include "checker/TSchecker.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { ETSLaunchExpression::ETSLaunchExpression(CallExpression *expr) @@ -41,6 +43,11 @@ void ETSLaunchExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ETSLaunchExpression"}, {"expr", expr_}}); } +void ETSLaunchExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ETSLaunchExpression"); +} + void ETSLaunchExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsLaunchExpression.h b/ets2panda/ir/ets/etsLaunchExpression.h index b8558ef6ec7d8a4e86b79d189827592d6407e121..5f41d342c81945a35e8e70c640bd38d2c7cb8000 100644 --- a/ets2panda/ir/ets/etsLaunchExpression.h +++ b/ets2panda/ir/ets/etsLaunchExpression.h @@ -50,6 +50,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp b/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp index 7ac314d183e4c1941af0cda89b55d111b22d2eb9..51c56de94e19e17160ef867b6c43f07898bc01cd 100644 --- a/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp +++ b/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" namespace panda::es2panda::ir { @@ -41,6 +42,17 @@ void ETSNewArrayInstanceExpression::Dump(ir::AstDumper *dumper) const {{"type", "ETSNewArrayInstanceExpression"}, {"typeReference", type_reference_}, {"dimension", dimension_}}); } +void ETSNewArrayInstanceExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("new "); + ASSERT(type_reference_); + type_reference_->Dump(dumper); + ASSERT(dimension_); + dumper->Add("["); + dimension_->Dump(dumper); + dumper->Add("]"); +} + void ETSNewArrayInstanceExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsNewArrayInstanceExpression.h b/ets2panda/ir/ets/etsNewArrayInstanceExpression.h index 27c4ab48bf0efb78edc99afb80f5ba04ae836d61..6486fc9f74156ac836cc342ce54aa81298584e16 100644 --- a/ets2panda/ir/ets/etsNewArrayInstanceExpression.h +++ b/ets2panda/ir/ets/etsNewArrayInstanceExpression.h @@ -72,6 +72,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp b/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp index 21e9c8c6d05d81d5723d30d1ccf4c91a3d72f17e..6d361fb6c023934ec004e989f156607115453b26 100644 --- a/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp +++ b/ets2panda/ir/ets/etsNewClassInstanceExpression.cpp @@ -19,6 +19,7 @@ #include "compiler/core/pandagen.h" #include "checker/TSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSNewClassInstanceExpression::TransformChildren(const NodeTransformer &cb) @@ -55,6 +56,22 @@ void ETSNewClassInstanceExpression::Dump(ir::AstDumper *dumper) const {"classBody", AstDumper::Optional(class_def_)}}); } +void ETSNewClassInstanceExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("new "); + if (type_reference_ != nullptr) { + type_reference_->Dump(dumper); + } + dumper->Add("("); + for (auto argument : arguments_) { + argument->Dump(dumper); + if (argument != arguments_.back()) { + dumper->Add(", "); + } + } + dumper->Add(")"); +} + void ETSNewClassInstanceExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsNewClassInstanceExpression.h b/ets2panda/ir/ets/etsNewClassInstanceExpression.h index 69b2bdd25688e46b6a9a3779a7c770433d9320ed..031531ca7439447d3bcfe41b3ee65cbbdda62ab0 100644 --- a/ets2panda/ir/ets/etsNewClassInstanceExpression.h +++ b/ets2panda/ir/ets/etsNewClassInstanceExpression.h @@ -87,7 +87,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp index f927e2d413bc556fcab1f2d9b8ae4a5d5137b202..4455ff7bb508f9cf844e9ea7272cc1019e7ca7a5 100644 --- a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp +++ b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp @@ -19,6 +19,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSNewMultiDimArrayInstanceExpression::TransformChildren(const NodeTransformer &cb) @@ -44,6 +46,18 @@ void ETSNewMultiDimArrayInstanceExpression::Dump(ir::AstDumper *dumper) const {"dimensions", dimensions_}}); } +void ETSNewMultiDimArrayInstanceExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("new "); + ASSERT(type_reference_); + type_reference_->Dump(dumper); + for (auto dim : dimensions_) { + dumper->Add("["); + dim->Dump(dumper); + dumper->Add("]"); + } +} + void ETSNewMultiDimArrayInstanceExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h index 189453beb3e7be97123dfc6dc7b774812655a75d..e031d1f230b67e8b190db7cc1aab14db90f957e3 100644 --- a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h +++ b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h @@ -89,7 +89,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsPackageDeclaration.cpp b/ets2panda/ir/ets/etsPackageDeclaration.cpp index b9fe930d937570c302abbced5ceb93cb917ae21b..27a44e419c25a17abcac4bbef2d311b10f7f4661 100644 --- a/ets2panda/ir/ets/etsPackageDeclaration.cpp +++ b/ets2panda/ir/ets/etsPackageDeclaration.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSPackageDeclaration::TransformChildren(const NodeTransformer &cb) @@ -36,6 +37,14 @@ void ETSPackageDeclaration::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ETSPackageDeclaration"}, {"name", name_}}); } +void ETSPackageDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("package "); + name_->Dump(dumper); + dumper->Add(";"); + dumper->Endl(); +} + void ETSPackageDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsPackageDeclaration.h b/ets2panda/ir/ets/etsPackageDeclaration.h index b16b4a1d3a62b8da3411586eb58bfcb2c52e2949..88d51f0c08ef9f2c1672532ca4b3abb1334fda04 100644 --- a/ets2panda/ir/ets/etsPackageDeclaration.h +++ b/ets2panda/ir/ets/etsPackageDeclaration.h @@ -40,7 +40,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsParameterExpression.cpp b/ets2panda/ir/ets/etsParameterExpression.cpp index 6065a8a5cea82dab8d4fe67c7e2991ec623d709b..23ac4ebd19f2dbb39d53eba092a0a002a9907112 100644 --- a/ets2panda/ir/ets/etsParameterExpression.cpp +++ b/ets2panda/ir/ets/etsParameterExpression.cpp @@ -21,6 +21,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" #include "ir/expressions/identifier.h" #include "ir/base/spreadElement.h" @@ -143,6 +144,30 @@ void ETSParameterExpression::Dump(ir::AstDumper *const dumper) const } } +void ETSParameterExpression::Dump(ir::SrcDumper *const dumper) const +{ + if (IsRestParameter()) { + spread_->Dump(dumper); + } else { + if (ident_ != nullptr) { + ASSERT(ident_->IsAnnotatedExpression()); + ident_->Dump(dumper); + auto type_annotation = ident_->AsAnnotatedExpression()->TypeAnnotation(); + if (type_annotation != nullptr) { + dumper->Add(": "); + type_annotation->Dump(dumper); + } + } + if (initializer_ != nullptr) { + ASSERT(initializer_->IsNumberLiteral()); + if (initializer_->AsNumberLiteral()->Str().Length() > 0) { + dumper->Add(" = "); + initializer_->Dump(dumper); + } + } + } +} + void ETSParameterExpression::Compile(compiler::PandaGen *const pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsParameterExpression.h b/ets2panda/ir/ets/etsParameterExpression.h index a58975af4f791cf5788e47106ff73ff73990da20..2bbe07083840b6fd49809c749b3416cc2c9857a1 100644 --- a/ets2panda/ir/ets/etsParameterExpression.h +++ b/ets2panda/ir/ets/etsParameterExpression.h @@ -84,6 +84,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void TransformChildren(const NodeTransformer &cb) override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsPrimitiveType.cpp b/ets2panda/ir/ets/etsPrimitiveType.cpp index f8debf89803a4bf2c1e7b11d8194eed7aa09bb42..cf436280e0058546e45a41a918030f0d0b879037 100644 --- a/ets2panda/ir/ets/etsPrimitiveType.cpp +++ b/ets2panda/ir/ets/etsPrimitiveType.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSPrimitiveType::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -30,6 +31,41 @@ void ETSPrimitiveType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ETSPrimitiveType"}}); } +void ETSPrimitiveType::Dump(ir::SrcDumper *dumper) const +{ + switch (GetPrimitiveType()) { + case PrimitiveType::BYTE: + dumper->Add("byte"); + break; + case PrimitiveType::INT: + dumper->Add("int"); + break; + case PrimitiveType::LONG: + dumper->Add("long"); + break; + case PrimitiveType::SHORT: + dumper->Add("short"); + break; + case PrimitiveType::FLOAT: + dumper->Add("float"); + break; + case PrimitiveType::DOUBLE: + dumper->Add("double"); + break; + case PrimitiveType::BOOLEAN: + dumper->Add("boolean"); + break; + case PrimitiveType::CHAR: + dumper->Add("char"); + break; + case PrimitiveType::VOID: + dumper->Add("void"); + break; + default: + UNREACHABLE(); + } +} + void ETSPrimitiveType::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsPrimitiveType.h b/ets2panda/ir/ets/etsPrimitiveType.h index 57cef567c8ff1e67edfe3d76c3475e8556532500..15afb7350d44ce2acde7107ae5a2d15fb7c979e4 100644 --- a/ets2panda/ir/ets/etsPrimitiveType.h +++ b/ets2panda/ir/ets/etsPrimitiveType.h @@ -33,6 +33,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsStructDeclaration.cpp b/ets2panda/ir/ets/etsStructDeclaration.cpp index 14f7101ad09c6d056deac938079fd3ada3aa2508..37026f4a624b1ec9c717e63a4a15b39a11ebd36d 100644 --- a/ets2panda/ir/ets/etsStructDeclaration.cpp +++ b/ets2panda/ir/ets/etsStructDeclaration.cpp @@ -20,6 +20,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/classDefinition.h" #include "ir/base/decorator.h" #include "ir/expressions/identifier.h" @@ -49,6 +50,11 @@ void ETSStructDeclaration::Dump(ir::AstDumper *dumper) const {{"type", "ETSStructDeclaration"}, {"definition", def_}, {"decorators", AstDumper::Optional(decorators_)}}); } +void ETSStructDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ETSStructDeclaration"); +} + void ETSStructDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsStructDeclaration.h b/ets2panda/ir/ets/etsStructDeclaration.h index 663f295b4bddb068f6656bd5ca2fd5a7f9ad77a2..43159c057294ae11d6ee98d4f68b709ddf608652 100644 --- a/ets2panda/ir/ets/etsStructDeclaration.h +++ b/ets2panda/ir/ets/etsStructDeclaration.h @@ -74,7 +74,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; - + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; diff --git a/ets2panda/ir/ets/etsTuple.cpp b/ets2panda/ir/ets/etsTuple.cpp index e289cfd474ba62bcbfa752f53d041d5f1662f6c3..13c879a2bf986a895be1aee3b7b2a3438c5d4d43 100644 --- a/ets2panda/ir/ets/etsTuple.cpp +++ b/ets2panda/ir/ets/etsTuple.cpp @@ -50,6 +50,22 @@ void ETSTuple::Dump(ir::AstDumper *const dumper) const {"spreadType", AstDumper::Nullish(spread_type_)}}); } +void ETSTuple::Dump(ir::SrcDumper *const dumper) const +{ + dumper->Add("["); + for (auto type_annot : type_annotation_list_) { + type_annot->Dump(dumper); + if (type_annot != type_annotation_list_.back() || spread_type_ != nullptr) { + dumper->Add(", "); + } + } + if (spread_type_ != nullptr) { + dumper->Add("..."); + spread_type_->Dump(dumper); + } + dumper->Add(("]")); +} + void ETSTuple::Compile([[maybe_unused]] compiler::PandaGen *const pg) const {} void ETSTuple::Compile([[maybe_unused]] compiler::ETSGen *const etsg) const {} diff --git a/ets2panda/ir/ets/etsTuple.h b/ets2panda/ir/ets/etsTuple.h index b0d6dc9fb1691f7c7514206b286a06250a8f759a..ce5af95a3a0f5c6d5b0e5f54a00b1de519257fd6 100644 --- a/ets2panda/ir/ets/etsTuple.h +++ b/ets2panda/ir/ets/etsTuple.h @@ -68,6 +68,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsTypeReference.cpp b/ets2panda/ir/ets/etsTypeReference.cpp index c763b3b38d0ccdfd656053c733322bddb404cef7..59b72fc8c6c9c9891fbd6d0dd5dc2dcbe9182d14 100644 --- a/ets2panda/ir/ets/etsTypeReference.cpp +++ b/ets2panda/ir/ets/etsTypeReference.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ts/tsQualifiedName.h" #include "ir/ets/etsTypeReferencePart.h" @@ -34,7 +35,7 @@ void ETSTypeReference::Iterate(const NodeTraverser &cb) const cb(part_); } -ir::Identifier *ETSTypeReference::BaseName() +ir::Identifier *ETSTypeReference::BaseName() const { ir::ETSTypeReferencePart *part_iter = part_; @@ -62,6 +63,12 @@ void ETSTypeReference::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ETSTypeReference"}, {"part", part_}}); } +void ETSTypeReference::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(part_ != nullptr); + part_->Dump(dumper); +} + void ETSTypeReference::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsTypeReference.h b/ets2panda/ir/ets/etsTypeReference.h index d37661e3736c6f2c134276db0be72af2551d7671..40b9e6c8dc690d14049dfa8859097779407a9ec7 100644 --- a/ets2panda/ir/ets/etsTypeReference.h +++ b/ets2panda/ir/ets/etsTypeReference.h @@ -36,11 +36,12 @@ public: return part_; } - ir::Identifier *BaseName(); + ir::Identifier *BaseName() const; void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsTypeReferencePart.cpp b/ets2panda/ir/ets/etsTypeReferencePart.cpp index add1f500347c2dbfbe2ecd874f1a9de2ea0dfc1f..767585e47ce797b58ae9463c545d284a26e7af18 100644 --- a/ets2panda/ir/ets/etsTypeReferencePart.cpp +++ b/ets2panda/ir/ets/etsTypeReferencePart.cpp @@ -21,6 +21,8 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" +#include "macros.h" namespace panda::es2panda::ir { void ETSTypeReferencePart::TransformChildren(const NodeTransformer &cb) @@ -57,6 +59,15 @@ void ETSTypeReferencePart::Dump(ir::AstDumper *dumper) const {"previous", AstDumper::Optional(prev_)}}); } +void ETSTypeReferencePart::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(name_ != nullptr); + name_->Dump(dumper); + if (type_params_ != nullptr) { + type_params_->Dump(dumper); + } +} + void ETSTypeReferencePart::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsTypeReferencePart.h b/ets2panda/ir/ets/etsTypeReferencePart.h index c5a50264427a2ddf1fb4432feb5ac08edbcca078..4facc1a6d3ab8fc495ea166b47d3837139733cf3 100644 --- a/ets2panda/ir/ets/etsTypeReferencePart.h +++ b/ets2panda/ir/ets/etsTypeReferencePart.h @@ -58,6 +58,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsUnionType.cpp b/ets2panda/ir/ets/etsUnionType.cpp index 3b07a4446d5679263e5234b2e36b3448ca3220f1..1e00c17a7c07f0dc642188edc3f88c8792c45592 100644 --- a/ets2panda/ir/ets/etsUnionType.cpp +++ b/ets2panda/ir/ets/etsUnionType.cpp @@ -17,6 +17,7 @@ #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ETSUnionType::TransformChildren(const NodeTransformer &cb) @@ -38,6 +39,16 @@ void ETSUnionType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ETSUnionType"}, {"types", types_}}); } +void ETSUnionType::Dump(ir::SrcDumper *dumper) const +{ + for (auto type : types_) { + type->Dump(dumper); + if (type != types_.back()) { + dumper->Add(" | "); + } + } +} + void ETSUnionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {} checker::Type *ETSUnionType::Check([[maybe_unused]] checker::TSChecker *checker) diff --git a/ets2panda/ir/ets/etsUnionType.h b/ets2panda/ir/ets/etsUnionType.h index 9b0e96ff4ed1e1875f8f1bc1e8bbeed007c00d1a..48b942d2cbcd75483e8f8699621c6aae1401a7ac 100644 --- a/ets2panda/ir/ets/etsUnionType.h +++ b/ets2panda/ir/ets/etsUnionType.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; checker::Type *Check([[maybe_unused]] checker::ETSChecker *checker) override; diff --git a/ets2panda/ir/ets/etsWildcardType.cpp b/ets2panda/ir/ets/etsWildcardType.cpp index 1ca7675248050e7252ed434b373615789367bfa6..f8c5a1880142c733110c74945c9a7986560b47c2 100644 --- a/ets2panda/ir/ets/etsWildcardType.cpp +++ b/ets2panda/ir/ets/etsWildcardType.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ets/etsTypeReference.h" namespace panda::es2panda::ir { @@ -45,6 +46,11 @@ void ETSWildcardType::Dump(ir::AstDumper *dumper) const {"out", AstDumper::Optional(IsOut())}}); } +void ETSWildcardType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ETSWildcardType"); +} + void ETSWildcardType::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ets/etsWildcardType.h b/ets2panda/ir/ets/etsWildcardType.h index b380fd348e85f68c0230e4e5bdd9598f8f3c194f..d633409a40732390799f964f2d62fdc800f4f073 100644 --- a/ets2panda/ir/ets/etsWildcardType.h +++ b/ets2panda/ir/ets/etsWildcardType.h @@ -37,6 +37,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/arrayExpression.cpp b/ets2panda/ir/expressions/arrayExpression.cpp index e620acd9eda9e729a7553f2c251ec7910c5e1d63..b1b2ef87a7e0a3a03a1d4e129890ab665c9ef780 100644 --- a/ets2panda/ir/expressions/arrayExpression.cpp +++ b/ets2panda/ir/expressions/arrayExpression.cpp @@ -24,11 +24,12 @@ #include "compiler/core/pandagen.h" #include "ir/astDump.h" #include "ir/base/decorator.h" +#include "ir/srcDump.h" +#include "ir/typeNode.h" #include "ir/base/spreadElement.h" #include "ir/expressions/assignmentExpression.h" #include "ir/expressions/identifier.h" #include "ir/expressions/objectExpression.h" -#include "ir/typeNode.h" #include "util/helpers.h" namespace panda::es2panda::ir { @@ -204,6 +205,18 @@ void ArrayExpression::Dump(ir::AstDumper *dumper) const {"optional", AstDumper::Optional(optional_)}}); } +void ArrayExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("["); + for (auto element : elements_) { + element->Dump(dumper); + if (element != elements_.back()) { + dumper->Add(", "); + } + } + dumper->Add("]"); +} + void ArrayExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/arrayExpression.h b/ets2panda/ir/expressions/arrayExpression.h index 50284260f208a837c1edcf8eb40f11e7626ae473..cd5f4132d0dc8e5926802fea3e3e1f635875516e 100644 --- a/ets2panda/ir/expressions/arrayExpression.h +++ b/ets2panda/ir/expressions/arrayExpression.h @@ -126,6 +126,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/arrowFunctionExpression.cpp b/ets2panda/ir/expressions/arrowFunctionExpression.cpp index 249aa83775ca2fd280db3a579968c7057328e502..4546f32031ba23e67bc238a48e9fb1264e86c6ea 100644 --- a/ets2panda/ir/expressions/arrowFunctionExpression.cpp +++ b/ets2panda/ir/expressions/arrowFunctionExpression.cpp @@ -21,6 +21,7 @@ #include "checker/ets/typeRelationContext.h" #include "checker/TSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/scriptFunction.h" #include "ir/ets/etsTypeReference.h" #include "ir/ets/etsTypeReferencePart.h" @@ -44,6 +45,11 @@ void ArrowFunctionExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ArrowFunctionExpression"}, {"function", func_}}); } +void ArrowFunctionExpression::Dump(ir::SrcDumper *dumper) const +{ + func_->Dump(dumper); +} + void ArrowFunctionExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/arrowFunctionExpression.h b/ets2panda/ir/expressions/arrowFunctionExpression.h index e7cd2df79b5d593c57bc0d7c93422c47db506bf3..bc40519398f98760eec73ab823ad2883492cbc74 100644 --- a/ets2panda/ir/expressions/arrowFunctionExpression.h +++ b/ets2panda/ir/expressions/arrowFunctionExpression.h @@ -89,6 +89,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/assignmentExpression.cpp b/ets2panda/ir/expressions/assignmentExpression.cpp index 175f28f0ff00107c132aabdb32ee27ed377af974..d916ecf588f5b5a476bc5f8bf28728a44044337d 100644 --- a/ets2panda/ir/expressions/assignmentExpression.cpp +++ b/ets2panda/ir/expressions/assignmentExpression.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/regScope.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/scriptFunction.h" #include "ir/base/spreadElement.h" #include "ir/expressions/identifier.h" @@ -119,6 +120,17 @@ void AssignmentExpression::Dump(ir::AstDumper *dumper) const } } +void AssignmentExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(left_); + left_->Dump(dumper); + dumper->Add(" "); + dumper->Add(TokenToString(operator_)); + dumper->Add(" "); + ASSERT(right_); + right_->Dump(dumper); +} + void AssignmentExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/assignmentExpression.h b/ets2panda/ir/expressions/assignmentExpression.h index 86a514565c5baa4882ad8e19375ea60b6c83c31b..976f93ca594ef25aae64a274b1757329721ed20d 100644 --- a/ets2panda/ir/expressions/assignmentExpression.h +++ b/ets2panda/ir/expressions/assignmentExpression.h @@ -120,6 +120,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; void CompilePattern(compiler::PandaGen *pg) const; diff --git a/ets2panda/ir/expressions/awaitExpression.cpp b/ets2panda/ir/expressions/awaitExpression.cpp index f0fac3d9b4137445cdb5c17883b24b020d4cd30c..5048bd86c4c62fe1875b9616575222fb9a2b907f 100644 --- a/ets2panda/ir/expressions/awaitExpression.cpp +++ b/ets2panda/ir/expressions/awaitExpression.cpp @@ -19,6 +19,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void AwaitExpression::TransformChildren(const NodeTransformer &cb) @@ -40,6 +41,11 @@ void AwaitExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "AwaitExpression"}, {"argument", AstDumper::Nullish(argument_)}}); } +void AwaitExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("AwaitExpression"); +} + void AwaitExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/awaitExpression.h b/ets2panda/ir/expressions/awaitExpression.h index 1a0a6c46c6b4d9c5e0c202f3549920c6a4b42ed8..ab1160ad375e45e0d074c89472bd8a47f42346fd 100644 --- a/ets2panda/ir/expressions/awaitExpression.h +++ b/ets2panda/ir/expressions/awaitExpression.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/binaryExpression.cpp b/ets2panda/ir/expressions/binaryExpression.cpp index 4da4ae6df90367cfee6b8b20a34fbc287ffe06bf..8375458ceb63a1097a5e50a663deeef6310b6776 100644 --- a/ets2panda/ir/expressions/binaryExpression.cpp +++ b/ets2panda/ir/expressions/binaryExpression.cpp @@ -18,6 +18,8 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "checker/TSchecker.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void BinaryExpression::TransformChildren(const NodeTransformer &cb) @@ -40,6 +42,19 @@ void BinaryExpression::Dump(ir::AstDumper *dumper) const {"right", right_}}); } +void BinaryExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(left_ != nullptr); + ASSERT(right_ != nullptr); + dumper->Add("("); + left_->Dump(dumper); + dumper->Add(" "); + dumper->Add(TokenToString(operator_)); + dumper->Add(" "); + right_->Dump(dumper); + dumper->Add(")"); +} + void BinaryExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/binaryExpression.h b/ets2panda/ir/expressions/binaryExpression.h index 89849ee786352ec556b6ddf252e18d7d77ae2405..82a2f61ba0597ad80ea7db433bfcee592d3d0ac3 100644 --- a/ets2panda/ir/expressions/binaryExpression.h +++ b/ets2panda/ir/expressions/binaryExpression.h @@ -148,6 +148,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/blockExpression.cpp b/ets2panda/ir/expressions/blockExpression.cpp index 02e3ff477e246e528a8228340ac990ac50948f50..f20c401f648b63ac0a373b2819380d68e413c35a 100644 --- a/ets2panda/ir/expressions/blockExpression.cpp +++ b/ets2panda/ir/expressions/blockExpression.cpp @@ -16,6 +16,7 @@ #include "blockExpression.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "compiler/core/ETSGen.h" #include "checker/ETSchecker.h" #include "ir/astNode.h" @@ -70,6 +71,16 @@ void BlockExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "BlockExpression"}, {"statements", statements_}}); } +void BlockExpression::Dump(ir::SrcDumper *dumper) const +{ + for (auto *statement : statements_) { + statement->Dump(dumper); + if (statement != statements_.back()) { + dumper->Endl(); + } + } +} + void BlockExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const { UNREACHABLE(); diff --git a/ets2panda/ir/expressions/blockExpression.h b/ets2panda/ir/expressions/blockExpression.h index 9e0a892b9abea8fdc3399fac0a0bb77b5033f0e9..6c6329ccd290328d853051c071a39ee337e183b7 100644 --- a/ets2panda/ir/expressions/blockExpression.h +++ b/ets2panda/ir/expressions/blockExpression.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/callExpression.cpp b/ets2panda/ir/expressions/callExpression.cpp index ede576373ea70522612a61638b02c15583b846f2..fc1be7c61162150cbf3cf433b82f42083f40424f 100644 --- a/ets2panda/ir/expressions/callExpression.cpp +++ b/ets2panda/ir/expressions/callExpression.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void CallExpression::TransformChildren(const NodeTransformer &cb) @@ -59,6 +61,20 @@ void CallExpression::Dump(ir::AstDumper *dumper) const {"typeParameters", AstDumper::Optional(type_params_)}}); } +void CallExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(callee_); + callee_->Dump(dumper); + dumper->Add("("); + for (auto arg : arguments_) { + arg->Dump(dumper); + if (arg != arguments_.back()) { + dumper->Add(", "); + } + } + dumper->Add(")"); +} + void CallExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/callExpression.h b/ets2panda/ir/expressions/callExpression.h index fc2add2887fb29a36668a61cb0e94654d3ee96fe..067c7fda46589698b88ede56a1a70ebba93964f4 100644 --- a/ets2panda/ir/expressions/callExpression.h +++ b/ets2panda/ir/expressions/callExpression.h @@ -148,6 +148,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/chainExpression.cpp b/ets2panda/ir/expressions/chainExpression.cpp index c7bddde72b0cdfb24d548f66af60e3e756b21a62..0c2ee1a5d0c1e53afe38033eaba119cb3b46d912 100644 --- a/ets2panda/ir/expressions/chainExpression.cpp +++ b/ets2panda/ir/expressions/chainExpression.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/memberExpression.h" namespace panda::es2panda::ir { @@ -37,6 +38,11 @@ void ChainExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ChainExpression"}, {"expression", expression_}}); } +void ChainExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ChainExpression"); +} + void ChainExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/chainExpression.h b/ets2panda/ir/expressions/chainExpression.h index 33e41e4cdba752920a1f3ccef98818d1d5b3edc0..0bd2bdb17220c1d82a66aec66a7fc10b565603bb 100644 --- a/ets2panda/ir/expressions/chainExpression.h +++ b/ets2panda/ir/expressions/chainExpression.h @@ -51,6 +51,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; void CompileToReg(compiler::PandaGen *pg, compiler::VReg &obj_reg) const; diff --git a/ets2panda/ir/expressions/classExpression.cpp b/ets2panda/ir/expressions/classExpression.cpp index b2fb7234fb02998b0509564d21397749e2fe10b0..6caf00999f2954395085a8dabebfe401ab4859b4 100644 --- a/ets2panda/ir/expressions/classExpression.cpp +++ b/ets2panda/ir/expressions/classExpression.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ClassExpression::TransformChildren(const NodeTransformer &cb) @@ -36,6 +37,11 @@ void ClassExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ClassExpression"}, {"definition", def_}}); } +void ClassExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ClassExpression"); +} + void ClassExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/classExpression.h b/ets2panda/ir/expressions/classExpression.h index 4970733dc93e49fed4869cf15ece2d6c8eba4fa0..3277ec23ae89f68e4ca2ee43640cc600fc100ab3 100644 --- a/ets2panda/ir/expressions/classExpression.h +++ b/ets2panda/ir/expressions/classExpression.h @@ -43,6 +43,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/conditionalExpression.cpp b/ets2panda/ir/expressions/conditionalExpression.cpp index 7c6c572c9f5beb283c48e87899eb7e5068f3cfcd..c75255d97188df4c7fbe4530b8f751ac084ef92d 100644 --- a/ets2panda/ir/expressions/conditionalExpression.cpp +++ b/ets2panda/ir/expressions/conditionalExpression.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ConditionalExpression::TransformChildren(const NodeTransformer &cb) @@ -40,6 +42,26 @@ void ConditionalExpression::Dump(ir::AstDumper *dumper) const {{"type", "ConditionalExpression"}, {"test", test_}, {"consequent", consequent_}, {"alternate", alternate_}}); } +void ConditionalExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(test_ != nullptr); + dumper->Add("("); + test_->Dump(dumper); + dumper->Add(" ? "); + if (consequent_ != nullptr) { + consequent_->Dump(dumper); + } + dumper->Add(" : "); + if (alternate_ != nullptr) { + alternate_->Dump(dumper); + } + dumper->Add(")"); + if ((parent_ != nullptr) && (parent_->IsBlockStatement() || parent_->IsBlockExpression())) { + dumper->Add(";"); + dumper->Endl(); + } +} + void ConditionalExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/conditionalExpression.h b/ets2panda/ir/expressions/conditionalExpression.h index 19cab1b07196380fdcb158257e9d63abdb0ece7d..58d76d14df7f2f0adbc90a9fd10783b192e564af 100644 --- a/ets2panda/ir/expressions/conditionalExpression.h +++ b/ets2panda/ir/expressions/conditionalExpression.h @@ -72,6 +72,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; diff --git a/ets2panda/ir/expressions/functionExpression.cpp b/ets2panda/ir/expressions/functionExpression.cpp index f8add6e7234e48c6f4a74b28da9f7b43106c9fdc..243a94df429a4bdb343ce2627d78015975ed0efc 100644 --- a/ets2panda/ir/expressions/functionExpression.cpp +++ b/ets2panda/ir/expressions/functionExpression.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void FunctionExpression::TransformChildren(const NodeTransformer &cb) @@ -36,6 +37,11 @@ void FunctionExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "FunctionExpression"}, {"function", func_}}); } +void FunctionExpression::Dump(ir::SrcDumper *dumper) const +{ + func_->Dump(dumper); +} + void FunctionExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/functionExpression.h b/ets2panda/ir/expressions/functionExpression.h index 754e520e350951d5a9691c8305c8bc5636b100b3..265bdc5fd3b59c4190914f5bfc65bbddd5d6d881 100644 --- a/ets2panda/ir/expressions/functionExpression.h +++ b/ets2panda/ir/expressions/functionExpression.h @@ -65,6 +65,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/identifier.cpp b/ets2panda/ir/expressions/identifier.cpp index 1913c2e1a1106f8be10bed070f2da6cdf2be1c27..03d77fb78166ad73d985284bf04b022e10861904 100644 --- a/ets2panda/ir/expressions/identifier.cpp +++ b/ets2panda/ir/expressions/identifier.cpp @@ -20,6 +20,8 @@ #include "checker/TSchecker.h" #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { Identifier::Identifier([[maybe_unused]] Tag const tag, Identifier const &other, ArenaAllocator *const allocator) @@ -91,6 +93,17 @@ void Identifier::Dump(ir::AstDumper *dumper) const {"decorators", decorators_}}); } +void Identifier::Dump(ir::SrcDumper *dumper) const +{ + if (IsPrivateIdent()) { + dumper->Add("private "); + } + dumper->Add(std::string(name_)); + if (IsOptional()) { + dumper->Add("?"); + } +} + void Identifier::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/identifier.h b/ets2panda/ir/expressions/identifier.h index 7c470996487a5bff38bd428eb069aaad231bd189..acbb027f93131d7e27c808e0965172a2d96f1b77 100644 --- a/ets2panda/ir/expressions/identifier.h +++ b/ets2panda/ir/expressions/identifier.h @@ -203,6 +203,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/importExpression.cpp b/ets2panda/ir/expressions/importExpression.cpp index c9d711027c00c9b54372f549cb3d629bcba390be..21a048c903dcaf08dab58a2b38a3546ee291101f 100644 --- a/ets2panda/ir/expressions/importExpression.cpp +++ b/ets2panda/ir/expressions/importExpression.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ImportExpression::TransformChildren(const NodeTransformer &cb) @@ -35,6 +37,11 @@ void ImportExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ImportExpression"}, {"source", source_}}); } +void ImportExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ImportExpression"); +} + void ImportExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/importExpression.h b/ets2panda/ir/expressions/importExpression.h index c4a099adeb1dfd05e62646a3fbfa8aa3ae2dcf1c..4ac17ab18829b21685e1b5da20902fe239257cde 100644 --- a/ets2panda/ir/expressions/importExpression.h +++ b/ets2panda/ir/expressions/importExpression.h @@ -40,6 +40,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/bigIntLiteral.cpp b/ets2panda/ir/expressions/literals/bigIntLiteral.cpp index b721e9db21a5c78a8259908b7e0975262a2ca0ba..a12339916cf09c833b73c2bb68976b8dfc8dcdc6 100644 --- a/ets2panda/ir/expressions/literals/bigIntLiteral.cpp +++ b/ets2panda/ir/expressions/literals/bigIntLiteral.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void BigIntLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -29,6 +30,11 @@ void BigIntLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "BigIntLiteral"}, {"value", src_}}); } +void BigIntLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add(std::string(src_)); +} + void BigIntLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/bigIntLiteral.h b/ets2panda/ir/expressions/literals/bigIntLiteral.h index 1180cc788c848d09ff0c949b77e2853cfe29b491..0ae06c26404386e01c7bb54e8af482b40257ef71 100644 --- a/ets2panda/ir/expressions/literals/bigIntLiteral.h +++ b/ets2panda/ir/expressions/literals/bigIntLiteral.h @@ -41,6 +41,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/booleanLiteral.cpp b/ets2panda/ir/expressions/literals/booleanLiteral.cpp index 1eb3eee725f0a60ea9df530ab55b7667cfb219b4..40bfa7bc655ee69bfa3c3dfc49ae8096f6ca392d 100644 --- a/ets2panda/ir/expressions/literals/booleanLiteral.cpp +++ b/ets2panda/ir/expressions/literals/booleanLiteral.cpp @@ -20,6 +20,7 @@ #include "checker/TSchecker.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void BooleanLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -30,6 +31,11 @@ void BooleanLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "BooleanLiteral"}, {"value", boolean_}}); } +void BooleanLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add(boolean_ ? "true" : "false"); +} + void BooleanLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/booleanLiteral.h b/ets2panda/ir/expressions/literals/booleanLiteral.h index 8974de1659cd941be07637d870f90bee5fbfb91c..88f62c6bf7280a0a8810fb478c66b0eaf201f8c5 100644 --- a/ets2panda/ir/expressions/literals/booleanLiteral.h +++ b/ets2panda/ir/expressions/literals/booleanLiteral.h @@ -40,6 +40,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/charLiteral.cpp b/ets2panda/ir/expressions/literals/charLiteral.cpp index 0a6adcf98d4e1c3056de72fcd47c9af2f197e251..ce4be05ffc2477b40d3f8b1285826beb78cb5d3c 100644 --- a/ets2panda/ir/expressions/literals/charLiteral.cpp +++ b/ets2panda/ir/expressions/literals/charLiteral.cpp @@ -20,7 +20,9 @@ #include "compiler/core/ETSGen.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" +#include #include namespace panda::es2panda::ir { @@ -32,6 +34,11 @@ void CharLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "CharLiteral"}, {"value", char_}}); } +void CharLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add(std::to_string(char_)); +} + void CharLiteral::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/charLiteral.h b/ets2panda/ir/expressions/literals/charLiteral.h index 619acec7b60e7c6b9cf7accb35626e61bd375efb..629e1a0d036151a3cbda6cc6a2bb4a19a3733274 100644 --- a/ets2panda/ir/expressions/literals/charLiteral.h +++ b/ets2panda/ir/expressions/literals/charLiteral.h @@ -46,6 +46,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/nullLiteral.cpp b/ets2panda/ir/expressions/literals/nullLiteral.cpp index f04d88b766385a9e260d2f7cc285ff2736a5938d..74c0e578162e27db70a51af734be3e39f602404a 100644 --- a/ets2panda/ir/expressions/literals/nullLiteral.cpp +++ b/ets2panda/ir/expressions/literals/nullLiteral.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void NullLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void NullLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "NullLiteral"}, {"value", AstDumper::Property::Constant::PROP_NULL}}); } +void NullLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("null"); +} + void NullLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/nullLiteral.h b/ets2panda/ir/expressions/literals/nullLiteral.h index 9089ec475715438aeae7f205bbeb65bbe972c0ee..4fb46bb414389a8f35e34285f693b6f90e81dd47 100644 --- a/ets2panda/ir/expressions/literals/nullLiteral.h +++ b/ets2panda/ir/expressions/literals/nullLiteral.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/numberLiteral.cpp b/ets2panda/ir/expressions/literals/numberLiteral.cpp index af42b4f5124cb49f114ad9383fa0336e0685bf90..dc7e40501b5050e86919f7ca6ca722669a150878 100644 --- a/ets2panda/ir/expressions/literals/numberLiteral.cpp +++ b/ets2panda/ir/expressions/literals/numberLiteral.cpp @@ -14,10 +14,13 @@ */ #include "numberLiteral.h" +#include #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void NumberLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +31,29 @@ void NumberLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "NumberLiteral"}, {"value", number_}}); } +void NumberLiteral::Dump(ir::SrcDumper *dumper) const +{ + if (number_.IsInt()) { + dumper->Add(number_.GetInt()); + return; + } + + if (number_.IsLong()) { + dumper->Add(number_.GetLong()); + return; + } + + if (number_.IsFloat()) { + dumper->Add(number_.GetFloat()); + return; + } + + if (number_.IsDouble()) { + dumper->Add(number_.GetDouble()); + return; + } +} + void NumberLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/numberLiteral.h b/ets2panda/ir/expressions/literals/numberLiteral.h index 6b05f8e34e6e9dc851e280f4ce4859647599fe6f..0abcbbce6ddbe60216a9803378b4413654f47078 100644 --- a/ets2panda/ir/expressions/literals/numberLiteral.h +++ b/ets2panda/ir/expressions/literals/numberLiteral.h @@ -55,6 +55,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/regExpLiteral.cpp b/ets2panda/ir/expressions/literals/regExpLiteral.cpp index 353d8fabb251a080ece8fdfb2bce87b42201acf2..d735658aafca94a3f57ca5a5095b8a4a38e35d14 100644 --- a/ets2panda/ir/expressions/literals/regExpLiteral.cpp +++ b/ets2panda/ir/expressions/literals/regExpLiteral.cpp @@ -20,6 +20,8 @@ #include "compiler/core/regScope.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void RegExpLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -30,6 +32,11 @@ void RegExpLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "RegExpLiteral"}, {"source", pattern_}, {"flags", flags_str_}}); } +void RegExpLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add(std::string(pattern_)); +} + void RegExpLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/regExpLiteral.h b/ets2panda/ir/expressions/literals/regExpLiteral.h index 57be86c6c2c387cb8fed093a0f003554785b5ba0..19b8582d1bb527f587c895b8f6454c06043a8643 100644 --- a/ets2panda/ir/expressions/literals/regExpLiteral.h +++ b/ets2panda/ir/expressions/literals/regExpLiteral.h @@ -50,6 +50,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/stringLiteral.cpp b/ets2panda/ir/expressions/literals/stringLiteral.cpp index 1406de9d88d2740d1acc685cfea6bdffbb35e3da..995b112d9b47824d446c1b99498c1edeb57b908b 100644 --- a/ets2panda/ir/expressions/literals/stringLiteral.cpp +++ b/ets2panda/ir/expressions/literals/stringLiteral.cpp @@ -14,10 +14,14 @@ */ #include "stringLiteral.h" +#include #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" +#include "macros.h" namespace panda::es2panda::ir { void StringLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +32,41 @@ void StringLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "StringLiteral"}, {"value", str_}}); } +void StringLiteral::Dump(ir::SrcDumper *dumper) const +{ + std::string str(str_); + std::string escaped_str; + escaped_str.push_back('\"'); + for (size_t i = 0, j = str_.Length(); i < j; ++i) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) + const char c = str_.Bytes()[i]; + // check if a given character is printable + // the cast is necessary to avoid undefined behaviour + if (std::isprint(static_cast(c)) != 0U) { + escaped_str.push_back(c); + } else { + escaped_str.push_back('\\'); + if (c == '\n') { + escaped_str.push_back('n'); + } else if (c == '\t') { + escaped_str.push_back('t'); + } else if (c == '\v') { + escaped_str.push_back('v'); + } else if (c == '\f') { + escaped_str.push_back('f'); + } else if (c == '\r') { + escaped_str.push_back('r'); + } else if (c == '\0') { + escaped_str.push_back('0'); + } else { + UNREACHABLE(); + } + } + } + escaped_str.push_back('\"'); + dumper->Add(escaped_str); +} + void StringLiteral::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/literals/stringLiteral.h b/ets2panda/ir/expressions/literals/stringLiteral.h index 09a19409de97040fbee70ccecdb70f5be0c8e464..081eed374fde1f4fce86bef53f75795b3a9095b7 100644 --- a/ets2panda/ir/expressions/literals/stringLiteral.h +++ b/ets2panda/ir/expressions/literals/stringLiteral.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/literals/undefinedLiteral.cpp b/ets2panda/ir/expressions/literals/undefinedLiteral.cpp index 2b2bc2ccc6c7e8f1ec03a1ee78da27c6fb854b6f..27bddb8b4078d63f8edf4676ad83d07621c24b6f 100644 --- a/ets2panda/ir/expressions/literals/undefinedLiteral.cpp +++ b/ets2panda/ir/expressions/literals/undefinedLiteral.cpp @@ -20,6 +20,7 @@ #include "checker/TSchecker.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void UndefinedLiteral::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -30,6 +31,11 @@ void UndefinedLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "UndefinedLiteral"}, {"value", AstDumper::Property::Constant::PROP_UNDEFINED}}); } +void UndefinedLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("undefined"); +} + void UndefinedLiteral::Compile(compiler::PandaGen *pg) const { pg->LoadConst(this, compiler::Constant::JS_UNDEFINED); diff --git a/ets2panda/ir/expressions/literals/undefinedLiteral.h b/ets2panda/ir/expressions/literals/undefinedLiteral.h index 3393da272fd3d783b16b4e23a6be968fc2fe832f..818867cde59e9820577967e67411f4bf873a9e30 100644 --- a/ets2panda/ir/expressions/literals/undefinedLiteral.h +++ b/ets2panda/ir/expressions/literals/undefinedLiteral.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/memberExpression.cpp b/ets2panda/ir/expressions/memberExpression.cpp index f099705db6b859f73037a56c54aff93ba87346b0..90a9fb50190deb2b3a1fb92b184e3c5ec0448389 100644 --- a/ets2panda/ir/expressions/memberExpression.cpp +++ b/ets2panda/ir/expressions/memberExpression.cpp @@ -19,6 +19,8 @@ #include "checker/ets/castingContext.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { MemberExpression::MemberExpression([[maybe_unused]] Tag const tag, MemberExpression const &other, @@ -62,6 +64,29 @@ void MemberExpression::Dump(ir::AstDumper *dumper) const {"optional", IsOptional()}}); } +void MemberExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(object_ != nullptr); + ASSERT(property_ != nullptr); + + object_->Dump(dumper); + if (IsOptional()) { + dumper->Add("?"); + } + if ((MemberExpressionKind::ELEMENT_ACCESS & kind_) != 0U) { + dumper->Add("["); + property_->Dump(dumper); + dumper->Add("]"); + } else { + dumper->Add("."); + property_->Dump(dumper); + } + if ((parent_ != nullptr) && (parent_->IsBlockStatement() || parent_->IsBlockExpression())) { + dumper->Add(";"); + dumper->Endl(); + } +} + void MemberExpression::LoadRhs(compiler::PandaGen *pg) const { compiler::RegScope rs(pg); diff --git a/ets2panda/ir/expressions/memberExpression.h b/ets2panda/ir/expressions/memberExpression.h index b59de63587ba99edaa5272c26c83e1c4f5ddb947..57305e315795f6b78c8313d45143b1813b838556 100644 --- a/ets2panda/ir/expressions/memberExpression.h +++ b/ets2panda/ir/expressions/memberExpression.h @@ -173,6 +173,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; bool CompileComputed(compiler::ETSGen *etsg) const; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; diff --git a/ets2panda/ir/expressions/newExpression.cpp b/ets2panda/ir/expressions/newExpression.cpp index 5959c7ffc15b3746e39404c6fb7b8d1fe3cc6ac3..f56cdeb805147dc9c04dea64b87a01bb9811a501 100644 --- a/ets2panda/ir/expressions/newExpression.cpp +++ b/ets2panda/ir/expressions/newExpression.cpp @@ -19,6 +19,8 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "util/helpers.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { NewExpression::NewExpression([[maybe_unused]] Tag const tag, NewExpression const &other, @@ -69,6 +71,11 @@ void NewExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "NewExpression"}, {"callee", callee_}, {"arguments", arguments_}}); } +void NewExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("NewExpression"); +} + void NewExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/newExpression.h b/ets2panda/ir/expressions/newExpression.h index 2fe51c8b6b740044b903a05601c7c705053481d7..a1d974cd3fee0d1a0cf847f28f432304e68b5677 100644 --- a/ets2panda/ir/expressions/newExpression.h +++ b/ets2panda/ir/expressions/newExpression.h @@ -59,6 +59,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/objectExpression.cpp b/ets2panda/ir/expressions/objectExpression.cpp index 18c4b401005f3d55908422ce693442e3cbd92e85..c9fc9d1ea7f8189d7f0a69df2d7d0d68e924eb2a 100644 --- a/ets2panda/ir/expressions/objectExpression.cpp +++ b/ets2panda/ir/expressions/objectExpression.cpp @@ -25,6 +25,7 @@ #include "checker/ets/typeRelationContext.h" #include "checker/ts/destructuringContext.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" #include "ir/base/property.h" #include "ir/base/scriptFunction.h" @@ -229,6 +230,11 @@ void ObjectExpression::Dump(ir::AstDumper *dumper) const {"optional", AstDumper::Optional(optional_)}}); } +void ObjectExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ObjectExpression"); +} + void ObjectExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/objectExpression.h b/ets2panda/ir/expressions/objectExpression.h index 0791b22622f777afa443561e01c4478af72f8e2a..9f8892ac5b6fed6d972b2c5a26bdb425c535543b 100644 --- a/ets2panda/ir/expressions/objectExpression.h +++ b/ets2panda/ir/expressions/objectExpression.h @@ -106,6 +106,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/omittedExpression.cpp b/ets2panda/ir/expressions/omittedExpression.cpp index babc86133ac90420c96ca79cf095ff5640e8cf8a..0ab3d1f33203eefd29e3f44e8ed5442c0d3860c3 100644 --- a/ets2panda/ir/expressions/omittedExpression.cpp +++ b/ets2panda/ir/expressions/omittedExpression.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void OmittedExpression::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void OmittedExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "OmittedExpression"}}); } +void OmittedExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("OmittedExpression"); +} + void OmittedExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/omittedExpression.h b/ets2panda/ir/expressions/omittedExpression.h index 10e0a39e964df17e4f7c4ad393b3b5969c16efc0..4f1f340b78dfb90e6b0069d7a7b7ece85daf6c68 100644 --- a/ets2panda/ir/expressions/omittedExpression.h +++ b/ets2panda/ir/expressions/omittedExpression.h @@ -35,6 +35,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/sequenceExpression.cpp b/ets2panda/ir/expressions/sequenceExpression.cpp index 477f6ef9d82bb5e8141820b6ff3daff93050dfcc..3830204255e2be254704e1b1fe96b17c82716c14 100644 --- a/ets2panda/ir/expressions/sequenceExpression.cpp +++ b/ets2panda/ir/expressions/sequenceExpression.cpp @@ -19,6 +19,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { SequenceExpression::SequenceExpression([[maybe_unused]] Tag const tag, SequenceExpression const &other, @@ -61,6 +63,16 @@ void SequenceExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "SequenceExpression"}, {"expressions", sequence_}}); } +void SequenceExpression::Dump(ir::SrcDumper *dumper) const +{ + for (auto *expr : sequence_) { + expr->Dump(dumper); + if (expr != sequence_.back()) { + dumper->Add(", "); + } + } +} + void SequenceExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/sequenceExpression.h b/ets2panda/ir/expressions/sequenceExpression.h index e34c0f7a1a7d8348ba0ebc036fa78eee2b91d34d..98c53be093291a81d397b3d45e3b209a0c983248 100644 --- a/ets2panda/ir/expressions/sequenceExpression.h +++ b/ets2panda/ir/expressions/sequenceExpression.h @@ -53,6 +53,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/superExpression.cpp b/ets2panda/ir/expressions/superExpression.cpp index 1b5c777ab87336e5ac079d33aea69a6224c41d1b..02e8244316ccb7c986413dbf8c83ae0aaa67a39e 100644 --- a/ets2panda/ir/expressions/superExpression.cpp +++ b/ets2panda/ir/expressions/superExpression.cpp @@ -20,6 +20,8 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "util/helpers.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void SuperExpression::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -30,6 +32,11 @@ void SuperExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "Super"}}); } +void SuperExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("super"); +} + void SuperExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/superExpression.h b/ets2panda/ir/expressions/superExpression.h index a5582fdad568ebd331ccb36a521ca853debb7dd3..29d12a994de0bed32b421f17ac355291e97b3b7e 100644 --- a/ets2panda/ir/expressions/superExpression.h +++ b/ets2panda/ir/expressions/superExpression.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/taggedTemplateExpression.cpp b/ets2panda/ir/expressions/taggedTemplateExpression.cpp index f13baf1d44905a7f1efdb674d4a21e170571bd70..1a4100fabaf7887517cbdc2ff073570e104d6a8a 100644 --- a/ets2panda/ir/expressions/taggedTemplateExpression.cpp +++ b/ets2panda/ir/expressions/taggedTemplateExpression.cpp @@ -22,6 +22,7 @@ #include "compiler/core/regScope.h" #include "checker/TSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/memberExpression.h" #include "ir/expressions/templateLiteral.h" #include "ir/ts/tsTypeParameterInstantiation.h" @@ -55,6 +56,11 @@ void TaggedTemplateExpression::Dump(ir::AstDumper *dumper) const {"typeParameters", AstDumper::Optional(type_params_)}}); } +void TaggedTemplateExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TaggedTemplateExpression"); +} + void TaggedTemplateExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/taggedTemplateExpression.h b/ets2panda/ir/expressions/taggedTemplateExpression.h index 5db6b47742986fa7779c1a72b58143b8a023869d..3d69e696e7cd00c0394d0ca35a92ae23dbbf39cc 100644 --- a/ets2panda/ir/expressions/taggedTemplateExpression.h +++ b/ets2panda/ir/expressions/taggedTemplateExpression.h @@ -57,6 +57,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/templateLiteral.cpp b/ets2panda/ir/expressions/templateLiteral.cpp index e6bbee9f4325dc779ec174b95272b6a39decd192..732c96706b0a4377f457ba7407123afc62fb755e 100644 --- a/ets2panda/ir/expressions/templateLiteral.cpp +++ b/ets2panda/ir/expressions/templateLiteral.cpp @@ -20,6 +20,7 @@ #include "checker/TSchecker.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/templateElement.h" namespace panda::es2panda::ir { @@ -77,6 +78,11 @@ void TemplateLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TemplateLiteral"}, {"expressions", expressions_}, {"quasis", quasis_}}); } +void TemplateLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TemplateLiteral"); +} + void TemplateLiteral::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/templateLiteral.h b/ets2panda/ir/expressions/templateLiteral.h index 7eb13149a9cccc5b8e6a4630a0e8610bcaf26380..046ea69c4f13e5e228751330bf8f09d6872b2433 100644 --- a/ets2panda/ir/expressions/templateLiteral.h +++ b/ets2panda/ir/expressions/templateLiteral.h @@ -54,6 +54,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/thisExpression.cpp b/ets2panda/ir/expressions/thisExpression.cpp index d8013b9d7a45e0dde9ab02cc9520978cf3032888..9598cea01a9637091955cd6b91a2cb479a84da51 100644 --- a/ets2panda/ir/expressions/thisExpression.cpp +++ b/ets2panda/ir/expressions/thisExpression.cpp @@ -26,6 +26,7 @@ #include "ir/base/methodDefinition.h" #include "ir/statements/blockStatement.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/callExpression.h" namespace panda::es2panda::ir { @@ -37,6 +38,11 @@ void ThisExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ThisExpression"}}); } +void ThisExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("this"); +} + void ThisExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/thisExpression.h b/ets2panda/ir/expressions/thisExpression.h index 061866025a90d746e69e4791472499c2922833b0..51ab0411293e170091a9ea594be62454044870ef 100644 --- a/ets2panda/ir/expressions/thisExpression.h +++ b/ets2panda/ir/expressions/thisExpression.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/unaryExpression.cpp b/ets2panda/ir/expressions/unaryExpression.cpp index b76d05d63fed73305d93f5097bf801ae19b58776..82601c41bfc70b374a26224a45c501f7d357d86a 100644 --- a/ets2panda/ir/expressions/unaryExpression.cpp +++ b/ets2panda/ir/expressions/unaryExpression.cpp @@ -21,6 +21,7 @@ #include "checker/TSchecker.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" #include "ir/expressions/literals/bigIntLiteral.h" #include "ir/expressions/literals/numberLiteral.h" @@ -43,6 +44,12 @@ void UnaryExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "UnaryExpression"}, {"operator", operator_}, {"prefix", true}, {"argument", argument_}}); } +void UnaryExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add(TokenToString(operator_)); + argument_->Dump(dumper); +} + void UnaryExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/unaryExpression.h b/ets2panda/ir/expressions/unaryExpression.h index b15dd94fd0b61c2840a459a6433992b0a19bbf09..b53c8c8de85910ea3fce07c58f31e73bf6796cd7 100644 --- a/ets2panda/ir/expressions/unaryExpression.h +++ b/ets2panda/ir/expressions/unaryExpression.h @@ -64,6 +64,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/updateExpression.cpp b/ets2panda/ir/expressions/updateExpression.cpp index 4f1fffbb898e0676b1bd06a36d184ab06b415047..5453e7543cf9303ea6550a828cedc953f6978fcd 100644 --- a/ets2panda/ir/expressions/updateExpression.cpp +++ b/ets2panda/ir/expressions/updateExpression.cpp @@ -15,6 +15,7 @@ #include "updateExpression.h" +#include "macros.h" #include "varbinder/variable.h" #include "compiler/base/lreference.h" #include "compiler/core/pandagen.h" @@ -23,6 +24,7 @@ #include "checker/TSchecker.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/unaryExpression.h" #include "ir/ts/tsAsExpression.h" #include "ir/expressions/identifier.h" @@ -44,6 +46,18 @@ void UpdateExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "UpdateExpression"}, {"operator", operator_}, {"prefix", prefix_}, {"argument", argument_}}); } +void UpdateExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(argument_); + if (prefix_) { + dumper->Add(TokenToString(operator_)); + argument_->Dump(dumper); + } else { + argument_->Dump(dumper); + dumper->Add(TokenToString(operator_)); + } +} + void UpdateExpression::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/updateExpression.h b/ets2panda/ir/expressions/updateExpression.h index 75300e97fc9641231560125f982a94d8fb5bfb3d..553d77315e3e638c4443b04d4521d40890446045 100644 --- a/ets2panda/ir/expressions/updateExpression.h +++ b/ets2panda/ir/expressions/updateExpression.h @@ -71,6 +71,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/expressions/yieldExpression.cpp b/ets2panda/ir/expressions/yieldExpression.cpp index 74b627b91403c2c00b821ca3a5770352941e5e17..36ce163da7007580178c8b8e8f8caf8c804930a2 100644 --- a/ets2panda/ir/expressions/yieldExpression.cpp +++ b/ets2panda/ir/expressions/yieldExpression.cpp @@ -20,6 +20,8 @@ #include "compiler/function/generatorFunctionBuilder.h" #include "checker/TSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" + namespace panda::es2panda::ir { void YieldExpression::TransformChildren(const NodeTransformer &cb) { @@ -40,6 +42,11 @@ void YieldExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "YieldExpression"}, {"delegate", delegate_}, {"argument", AstDumper::Nullish(argument_)}}); } +void YieldExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("YieldExpression"); +} + void YieldExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/expressions/yieldExpression.h b/ets2panda/ir/expressions/yieldExpression.h index 25a10a6e00bc2f125a3d1443f6e4d4ed12ba1cbb..1f78687a9ce9381ae64734f0965e479b202e6362 100644 --- a/ets2panda/ir/expressions/yieldExpression.h +++ b/ets2panda/ir/expressions/yieldExpression.h @@ -52,6 +52,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/exportAllDeclaration.cpp b/ets2panda/ir/module/exportAllDeclaration.cpp index c34cb356e49c57204f7920e1862daed02a77ec6d..4ffeaef3a0b47d47681e20c993a4caeb9a14d4ae 100644 --- a/ets2panda/ir/module/exportAllDeclaration.cpp +++ b/ets2panda/ir/module/exportAllDeclaration.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ExportAllDeclaration::TransformChildren(const NodeTransformer &cb) @@ -43,6 +45,11 @@ void ExportAllDeclaration::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ExportAllDeclaration"}, {"source", source_}, {"exported", AstDumper::Nullish(exported_)}}); } +void ExportAllDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ExportAllDeclaration"); +} + void ExportAllDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/exportAllDeclaration.h b/ets2panda/ir/module/exportAllDeclaration.h index a472a1fd5f0d61613a19c6cc30d301a18f70529a..12e40b170f2cceca9a9f4c8e200cf9d610061755 100644 --- a/ets2panda/ir/module/exportAllDeclaration.h +++ b/ets2panda/ir/module/exportAllDeclaration.h @@ -42,6 +42,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/exportDefaultDeclaration.cpp b/ets2panda/ir/module/exportDefaultDeclaration.cpp index 82e090025be581f9ea29b24ed39d83d1c7bc210f..5506246c54364eebe23fd0ff15469322a5cd1361 100644 --- a/ets2panda/ir/module/exportDefaultDeclaration.cpp +++ b/ets2panda/ir/module/exportDefaultDeclaration.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ExportDefaultDeclaration::TransformChildren(const NodeTransformer &cb) @@ -36,6 +38,11 @@ void ExportDefaultDeclaration::Dump(ir::AstDumper *dumper) const {{"type", IsExportEquals() ? "TSExportAssignment" : "ExportDefaultDeclaration"}, {"declaration", decl_}}); } +void ExportDefaultDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ExportDefaultDeclaration"); +} + void ExportDefaultDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/exportDefaultDeclaration.h b/ets2panda/ir/module/exportDefaultDeclaration.h index 532098f023e933728ae9bcba7caa6b3502eb8ae1..b92eff1366307a61036df168dc59cb8119299879 100644 --- a/ets2panda/ir/module/exportDefaultDeclaration.h +++ b/ets2panda/ir/module/exportDefaultDeclaration.h @@ -44,6 +44,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/exportNamedDeclaration.cpp b/ets2panda/ir/module/exportNamedDeclaration.cpp index ff886326fd879b9e8fe06e74fdf6dde74a11d3d6..662a4de79ba031c78336baef11b3bc40a65cdb7e 100644 --- a/ets2panda/ir/module/exportNamedDeclaration.cpp +++ b/ets2panda/ir/module/exportNamedDeclaration.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ExportNamedDeclaration::TransformChildren(const NodeTransformer &cb) @@ -67,6 +69,11 @@ void ExportNamedDeclaration::Dump(ir::AstDumper *dumper) const {"specifiers", specifiers_}}); } +void ExportNamedDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ExportNamedDeclaration"); +} + void ExportNamedDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/exportNamedDeclaration.h b/ets2panda/ir/module/exportNamedDeclaration.h index 78a515225b4257dba198d3f24e2e0a8b0785d46c..4a5a8c7d858e972825dc1272814eb8fe0cae438c 100644 --- a/ets2panda/ir/module/exportNamedDeclaration.h +++ b/ets2panda/ir/module/exportNamedDeclaration.h @@ -78,6 +78,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/exportSpecifier.cpp b/ets2panda/ir/module/exportSpecifier.cpp index 2aa19dee82c77cf7cb630552fde92cc83c183f9c..0f728c080021405bf5f0dcdcaadd2b834cdababe 100644 --- a/ets2panda/ir/module/exportSpecifier.cpp +++ b/ets2panda/ir/module/exportSpecifier.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ExportSpecifier::TransformChildren(const NodeTransformer &cb) @@ -37,6 +39,11 @@ void ExportSpecifier::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ExportSpecifier"}, {"local", local_}, {"exported", exported_}}); } +void ExportSpecifier::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ExportSpecifier"); +} + void ExportSpecifier::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/exportSpecifier.h b/ets2panda/ir/module/exportSpecifier.h index 1770e7f06504b62d760ea2acb045684208d1ef34..ac0cf334dc4c16846ca099a0777cfb259b2f24da 100644 --- a/ets2panda/ir/module/exportSpecifier.h +++ b/ets2panda/ir/module/exportSpecifier.h @@ -41,6 +41,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/importDeclaration.cpp b/ets2panda/ir/module/importDeclaration.cpp index e1208b0d02a56bb3b2eb6ba72753ec14817a2ede..70b22948b2c8c09f165442884cbc7097478df542 100644 --- a/ets2panda/ir/module/importDeclaration.cpp +++ b/ets2panda/ir/module/importDeclaration.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ImportDeclaration::TransformChildren(const NodeTransformer &cb) @@ -43,6 +45,23 @@ void ImportDeclaration::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ImportDeclaration"}, {"source", source_}, {"specifiers", specifiers_}}); } +void ImportDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("import "); + for (auto specifier : specifiers_) { + specifier->Dump(dumper); + if (specifier != specifiers_.back()) { + dumper->Add(", "); + } else { + dumper->Add(" "); + } + } + dumper->Add("from "); + source_->Dump(dumper); + dumper->Add(";"); + dumper->Endl(); +} + void ImportDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/importDeclaration.h b/ets2panda/ir/module/importDeclaration.h index fa7251ef8f63b3c9b74616e2b0253f3af19b9aa4..fc9d2a1e84d2504108edb79ca197cadc3b0289fd 100644 --- a/ets2panda/ir/module/importDeclaration.h +++ b/ets2panda/ir/module/importDeclaration.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/importDefaultSpecifier.cpp b/ets2panda/ir/module/importDefaultSpecifier.cpp index ea4a43b93e199df6aa0178d0fbca81eb82e89459..1999c374ffe14688129f4b28fd98077bb617f1da 100644 --- a/ets2panda/ir/module/importDefaultSpecifier.cpp +++ b/ets2panda/ir/module/importDefaultSpecifier.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ImportDefaultSpecifier::TransformChildren(const NodeTransformer &cb) @@ -35,6 +37,11 @@ void ImportDefaultSpecifier::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ImportDefaultSpecifier"}, {"local", local_}}); } +void ImportDefaultSpecifier::Dump(ir::SrcDumper *dumper) const +{ + local_->Dump(dumper); +} + void ImportDefaultSpecifier::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/importDefaultSpecifier.h b/ets2panda/ir/module/importDefaultSpecifier.h index c698045b76b1df77d85509ac642be1496341b9f3..1df936b8742b6604815795580f13a1af84a151e6 100644 --- a/ets2panda/ir/module/importDefaultSpecifier.h +++ b/ets2panda/ir/module/importDefaultSpecifier.h @@ -35,6 +35,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/importNamespaceSpecifier.cpp b/ets2panda/ir/module/importNamespaceSpecifier.cpp index 44660316c6ed0e0860617c2d976c7e8f2a24316b..406f735a82e3eeaf91cd7b1d7b754326cad8da8a 100644 --- a/ets2panda/ir/module/importNamespaceSpecifier.cpp +++ b/ets2panda/ir/module/importNamespaceSpecifier.cpp @@ -19,6 +19,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ImportNamespaceSpecifier::TransformChildren(const NodeTransformer &cb) @@ -36,6 +38,11 @@ void ImportNamespaceSpecifier::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ImportNamespaceSpecifier"}, {"local", local_}}); } +void ImportNamespaceSpecifier::Dump(ir::SrcDumper *dumper) const +{ + local_->Dump(dumper); +} + void ImportNamespaceSpecifier::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/importNamespaceSpecifier.h b/ets2panda/ir/module/importNamespaceSpecifier.h index e4bbeaccb49224d3cc4c70f5f26ec9238479c801..3b79e7f1bf6b37da684bbb5251a5466460aa6f62 100644 --- a/ets2panda/ir/module/importNamespaceSpecifier.h +++ b/ets2panda/ir/module/importNamespaceSpecifier.h @@ -41,6 +41,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/module/importSpecifier.cpp b/ets2panda/ir/module/importSpecifier.cpp index 984e4137d5861c8b746bb2fc0bbe2a63f02e5559..632e363f45961156816c3ad286878f6746785423 100644 --- a/ets2panda/ir/module/importSpecifier.cpp +++ b/ets2panda/ir/module/importSpecifier.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ImportSpecifier::TransformChildren(const NodeTransformer &cb) @@ -41,6 +43,11 @@ void ImportSpecifier::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ImportSpecifier"}, {"local", ir::AstDumper::Optional(local_)}, {"imported", imported_}}); } +void ImportSpecifier::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ImportSpecifier"); +} + void ImportSpecifier::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/module/importSpecifier.h b/ets2panda/ir/module/importSpecifier.h index 2aad8a29eac19448c42c7efcffb166a939a3307a..4f98dd150f7b475b621295e268221d49a8ca4e5e 100644 --- a/ets2panda/ir/module/importSpecifier.h +++ b/ets2panda/ir/module/importSpecifier.h @@ -51,6 +51,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/opaqueTypeNode.cpp b/ets2panda/ir/opaqueTypeNode.cpp index b09b065cb4cba3e35869a2cb44a6855fa5e8fb3b..ec0bc61948898dba54e9500c1168f1267531178b 100644 --- a/ets2panda/ir/opaqueTypeNode.cpp +++ b/ets2panda/ir/opaqueTypeNode.cpp @@ -18,6 +18,8 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" + namespace panda::es2panda::ir { void OpaqueTypeNode::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void OpaqueTypeNode::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "OpaqueType"}}); } +void OpaqueTypeNode::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("OpaqueTypeNode"); +} + void OpaqueTypeNode::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/opaqueTypeNode.h b/ets2panda/ir/opaqueTypeNode.h index c37708193eac1118d4d8aa34928b50cadd09bca9..3f31940809f5fcb739ac04d7ba221ddb78012c1c 100644 --- a/ets2panda/ir/opaqueTypeNode.h +++ b/ets2panda/ir/opaqueTypeNode.h @@ -39,6 +39,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/srcDump.cpp b/ets2panda/ir/srcDump.cpp new file mode 100644 index 0000000000000000000000000000000000000000..7913711200f63f6b45eaa10d5e416b2acab31a1d --- /dev/null +++ b/ets2panda/ir/srcDump.cpp @@ -0,0 +1,77 @@ +/** + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "srcDump.h" + +#include + +#include +#include + +namespace panda::es2panda::ir { + +SrcDumper::SrcDumper(const ir::AstNode *node) +{ + node->Dump(this); +} + +void SrcDumper::IncrIndent() +{ + indent_.push_back(' '); + indent_.push_back(' '); +} + +void SrcDumper::DecrIndent() +{ + if (indent_.size() >= 2U) { + indent_.pop_back(); + indent_.pop_back(); + } +} + +void SrcDumper::Endl(size_t num) +{ + while (num != 0U) { + ss_ << std::endl; + --num; + } + ss_ << indent_; +} + +void SrcDumper::Add(const std::string &str) +{ + ss_ << str; +} + +void SrcDumper::Add(const int32_t i) +{ + ss_ << i; +} + +void SrcDumper::Add(const int64_t l) +{ + ss_ << l; +} + +void SrcDumper::Add(const float f) +{ + ss_ << f; +} + +void SrcDumper::Add(const double d) +{ + ss_ << d; +} +} // namespace panda::es2panda::ir diff --git a/ets2panda/ir/srcDump.h b/ets2panda/ir/srcDump.h new file mode 100644 index 0000000000000000000000000000000000000000..f80c81942f02e1fe70055eb72e6c5be5d62fe669 --- /dev/null +++ b/ets2panda/ir/srcDump.h @@ -0,0 +1,54 @@ +/** + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ES2PANDA_IR_SRCDUMP_H +#define ES2PANDA_IR_SRCDUMP_H + +#include +#include +#include +#include + +#include +#include + +namespace panda::es2panda::ir { + +class SrcDumper { +public: + explicit SrcDumper(const ir::AstNode *node); + + void Add(const std::string &str); + void Add(int32_t i); + void Add(int64_t l); + void Add(float f); + void Add(double d); + + std::string Str() const + { + return ss_.str(); + } + + void IncrIndent(); + void DecrIndent(); + void Endl(size_t num = 1); + +private: + std::stringstream ss_; + std::string indent_; +}; +} // namespace panda::es2panda::ir + +#endif // ES2PANDA_IR_SRCDUMP_H diff --git a/ets2panda/ir/statements/assertStatement.cpp b/ets2panda/ir/statements/assertStatement.cpp index 4b09acd2363cb58e067ae6d980f16ba92745b84f..393cdea5ad8ea8835f5dede22caddcd1f1bf8fd7 100644 --- a/ets2panda/ir/statements/assertStatement.cpp +++ b/ets2panda/ir/statements/assertStatement.cpp @@ -22,6 +22,7 @@ #include "checker/ETSchecker.h" #include "checker/TSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" namespace panda::es2panda::ir { @@ -48,6 +49,17 @@ void AssertStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "AssertStatement"}, {"test", test_}, {"second", AstDumper::Nullish(second_)}}); } +void AssertStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(test_); + dumper->Add("assert("); + test_->Dump(dumper); + dumper->Add(")"); + if (parent_->IsStatement()) { + dumper->Add(";"); + } +} + void AssertStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/assertStatement.h b/ets2panda/ir/statements/assertStatement.h index 504911064fcf87b25d8a7bfd115d34e3dbce6d1a..88b468ad9f2da3c0b18e7ce94b5a416566b30692 100644 --- a/ets2panda/ir/statements/assertStatement.h +++ b/ets2panda/ir/statements/assertStatement.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/blockStatement.cpp b/ets2panda/ir/statements/blockStatement.cpp index 4bb8908d3267e607162f9dadd5ee17defdd5a595..76b50d2aded146df37dcf85a46a7d345f6caa7f0 100644 --- a/ets2panda/ir/statements/blockStatement.cpp +++ b/ets2panda/ir/statements/blockStatement.cpp @@ -22,6 +22,7 @@ #include "checker/TSchecker.h" #include "checker/ETSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void BlockStatement::TransformChildren(const NodeTransformer &cb) @@ -43,6 +44,17 @@ void BlockStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", IsProgram() ? "Program" : "BlockStatement"}, {"statements", statements_}}); } +void BlockStatement::Dump(ir::SrcDumper *dumper) const +{ + // NOTE(nsizov): trailing blocks + for (auto statement : statements_) { + statement->Dump(dumper); + if (statement != statements_.back()) { + dumper->Endl(); + } + } +} + void BlockStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/blockStatement.h b/ets2panda/ir/statements/blockStatement.h index 6f75c047d831deff62b4f241e8bc88277f03dc02..a3c1f9529b3d74094df7eadb6b99dc97db771222 100644 --- a/ets2panda/ir/statements/blockStatement.h +++ b/ets2panda/ir/statements/blockStatement.h @@ -77,6 +77,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/breakStatement.cpp b/ets2panda/ir/statements/breakStatement.cpp index 674edc681c0e989196b346678710c8d284341d38..50cff0716433fd069f61f6a95eb2982dffe7f0df 100644 --- a/ets2panda/ir/statements/breakStatement.cpp +++ b/ets2panda/ir/statements/breakStatement.cpp @@ -19,6 +19,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" #include "checker/ETSchecker.h" @@ -42,6 +43,16 @@ void BreakStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "BreakStatement"}, {"label", AstDumper::Nullish(ident_)}}); } +void BreakStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("break"); + if (ident_ != nullptr) { + dumper->Add(" "); + ident_->Dump(dumper); + } + dumper->Add(";"); +} + void BreakStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/breakStatement.h b/ets2panda/ir/statements/breakStatement.h index 67f4b944faaf85148d72ab5a5d980c52a3045325..35ffa3fa4fcc07ac72ff46891e8522feebac26eb 100644 --- a/ets2panda/ir/statements/breakStatement.h +++ b/ets2panda/ir/statements/breakStatement.h @@ -50,6 +50,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/classDeclaration.cpp b/ets2panda/ir/statements/classDeclaration.cpp index 627e9bece0a42037e8d65b33e331a28d9073671d..5e2b38767bf54d2e79c55418e3f7532865a362c7 100644 --- a/ets2panda/ir/statements/classDeclaration.cpp +++ b/ets2panda/ir/statements/classDeclaration.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ClassDeclaration::TransformChildren(const NodeTransformer &cb) @@ -43,6 +45,15 @@ void ClassDeclaration::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ClassDeclaration"}, {"definition", def_}, {"decorators", AstDumper::Optional(decorators_)}}); } +void ClassDeclaration::Dump(ir::SrcDumper *dumper) const +{ + if (def_ != nullptr) { + def_->Dump(dumper); + } + // NOTE(nsizov): support decorators when supported in ArkTS + ASSERT(decorators_.empty()); +} + void ClassDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/classDeclaration.h b/ets2panda/ir/statements/classDeclaration.h index c6e5925b4c25b6ddfc8fd92f2a56665cbf36bda2..acc51c23e1b24e93ca23a150df384e79c15cd304 100644 --- a/ets2panda/ir/statements/classDeclaration.h +++ b/ets2panda/ir/statements/classDeclaration.h @@ -59,6 +59,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; diff --git a/ets2panda/ir/statements/continueStatement.cpp b/ets2panda/ir/statements/continueStatement.cpp index da58f870ae1043602b4e21bcb8460c06f4742262..6b9739ecc3ff7a717506177ee2356399af48f9ef 100644 --- a/ets2panda/ir/statements/continueStatement.cpp +++ b/ets2panda/ir/statements/continueStatement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ContinueStatement::TransformChildren(const NodeTransformer &cb) @@ -39,6 +41,11 @@ void ContinueStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ContinueStatement"}, {"label", AstDumper::Nullish(ident_)}}); } +void ContinueStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("continue;"); +} + void ContinueStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/continueStatement.h b/ets2panda/ir/statements/continueStatement.h index 857b43f7f63cb4aece3c0c9c5cdf14ee8a6c6263..2ccb751024eb57693ae5e87f0f257fa4234f26e6 100644 --- a/ets2panda/ir/statements/continueStatement.h +++ b/ets2panda/ir/statements/continueStatement.h @@ -50,6 +50,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/debuggerStatement.cpp b/ets2panda/ir/statements/debuggerStatement.cpp index b0bb23faadd70a585650ec54cd7d21c5988d5c0f..9ae8e40d5aebb683aae5f3fc03ce67a5365384d1 100644 --- a/ets2panda/ir/statements/debuggerStatement.cpp +++ b/ets2panda/ir/statements/debuggerStatement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void DebuggerStatement::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void DebuggerStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "DebuggerStatement"}}); } +void DebuggerStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("DebuggerStatement"); +} + void DebuggerStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/debuggerStatement.h b/ets2panda/ir/statements/debuggerStatement.h index 70feeb4698aff7f811d7b7998b549fd8588efa8b..de1e2f4024b4f1aa211d95776578d7ae443f04b7 100644 --- a/ets2panda/ir/statements/debuggerStatement.h +++ b/ets2panda/ir/statements/debuggerStatement.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/doWhileStatement.cpp b/ets2panda/ir/statements/doWhileStatement.cpp index 93d2a413e6a8e2efabe04fa0d386c38083230573..769d97bd556382b09bdc0c06fc3f11ac461a51bd 100644 --- a/ets2panda/ir/statements/doWhileStatement.cpp +++ b/ets2panda/ir/statements/doWhileStatement.cpp @@ -14,6 +14,7 @@ */ #include "doWhileStatement.h" +#include #include "varbinder/scope.h" #include "compiler/base/condition.h" @@ -21,6 +22,8 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "checker/TSchecker.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void DoWhileStatement::TransformChildren(const NodeTransformer &cb) @@ -40,6 +43,24 @@ void DoWhileStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "DoWhileStatement"}, {"body", body_}, {"test", test_}}); } +void DoWhileStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("do {"); + if (body_ != nullptr) { + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("} while"); + dumper->Add("("); + if (test_ != nullptr) { + test_->Dump(dumper); + } + dumper->Add(")"); +} + void DoWhileStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/doWhileStatement.h b/ets2panda/ir/statements/doWhileStatement.h index dbae0763e6d5ee38e796b221e4ee8a481df1a265..487dd589c538e7b326670eedce7f532c31bacb51 100644 --- a/ets2panda/ir/statements/doWhileStatement.h +++ b/ets2panda/ir/statements/doWhileStatement.h @@ -62,6 +62,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/emptyStatement.cpp b/ets2panda/ir/statements/emptyStatement.cpp index 4c00f2a89ee6f42aea577b5c9121229994a54b11..a5a9bab6c2c8b9907b2714498507e8d2bd3c2e93 100644 --- a/ets2panda/ir/statements/emptyStatement.cpp +++ b/ets2panda/ir/statements/emptyStatement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void EmptyStatement::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void EmptyStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "EmptyStatement"}}); } +void EmptyStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("EmptyStatement"); +} + void EmptyStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/emptyStatement.h b/ets2panda/ir/statements/emptyStatement.h index a8ac9416a8aaf286c3628a894df06c8848c382fe..f6d86e6cf5743711cf019870985d1d8ccbde67ad 100644 --- a/ets2panda/ir/statements/emptyStatement.h +++ b/ets2panda/ir/statements/emptyStatement.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/expressionStatement.cpp b/ets2panda/ir/statements/expressionStatement.cpp index d4750832be8cdad6688db5c3f34f4f80185336df..2f10412f4e791993388e7703adf14503b654567a 100644 --- a/ets2panda/ir/statements/expressionStatement.cpp +++ b/ets2panda/ir/statements/expressionStatement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ExpressionStatement::TransformChildren(const NodeTransformer &cb) @@ -35,6 +37,18 @@ void ExpressionStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ExpressionStatement"}, {"expression", expression_}}); } +void ExpressionStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(expression_ != nullptr); + expression_->Dump(dumper); + if ((parent_ != nullptr) && (parent_->IsBlockStatement() || parent_->IsSwitchCaseStatement())) { + dumper->Add(";"); + if (parent_->IsSwitchCaseStatement()) { + dumper->Endl(); + } + } +} + void ExpressionStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/expressionStatement.h b/ets2panda/ir/statements/expressionStatement.h index 57e061a22a7774bb7599eb43ac68b9e66802c697..85da0d28775b77c80cac931f8b3121c439433a57 100644 --- a/ets2panda/ir/statements/expressionStatement.h +++ b/ets2panda/ir/statements/expressionStatement.h @@ -38,6 +38,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/forInStatement.cpp b/ets2panda/ir/statements/forInStatement.cpp index 331be2f2fff94081c1ae8d4b1b8527e784c91c1a..a1344d73628bf47889736234ba358440928163ec 100644 --- a/ets2panda/ir/statements/forInStatement.cpp +++ b/ets2panda/ir/statements/forInStatement.cpp @@ -21,6 +21,8 @@ #include "compiler/core/pandagen.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ForInStatement::TransformChildren(const NodeTransformer &cb) @@ -42,6 +44,11 @@ void ForInStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ForInStatement"}, {"left", left_}, {"right", right_}, {"body", body_}}); } +void ForInStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("ForInStatement"); +} + void ForInStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/forInStatement.h b/ets2panda/ir/statements/forInStatement.h index 13f428e3b9fef1f6f4934b4b27cde1ea720a2824..0702403edb424bb998b8d693b6f2baa7a5559a56 100644 --- a/ets2panda/ir/statements/forInStatement.h +++ b/ets2panda/ir/statements/forInStatement.h @@ -72,6 +72,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/forOfStatement.cpp b/ets2panda/ir/statements/forOfStatement.cpp index 50cb1e9d1c9e63c719ed6236d68ed35d2f2d12e8..7ce6be2d4482e59613274240ce84337b9bc15360 100644 --- a/ets2panda/ir/statements/forOfStatement.cpp +++ b/ets2panda/ir/statements/forOfStatement.cpp @@ -15,6 +15,7 @@ #include "forOfStatement.h" +#include "macros.h" #include "varbinder/scope.h" #include "compiler/base/iterators.h" #include "compiler/base/lreference.h" @@ -22,6 +23,8 @@ #include "checker/TSchecker.h" #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ForOfStatement::TransformChildren(const NodeTransformer &cb) @@ -44,6 +47,29 @@ void ForOfStatement::Dump(ir::AstDumper *dumper) const {{"type", "ForOfStatement"}, {"await", is_await_}, {"left", left_}, {"right", right_}, {"body", body_}}); } +void ForOfStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(left_ != nullptr); + ASSERT(right_ != nullptr); + dumper->Add("for "); + if (is_await_) { + dumper->Add("await "); + } + dumper->Add("("); + left_->Dump(dumper); + dumper->Add(" of "); + right_->Dump(dumper); + dumper->Add(") {"); + if (body_ != nullptr) { + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("}"); +} + void ForOfStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/forOfStatement.h b/ets2panda/ir/statements/forOfStatement.h index 9a2e9ba8a0c55005420b61a007929860e6fe5bb0..2d5fbbb250df71e6db1a6864f203cef987c4c368 100644 --- a/ets2panda/ir/statements/forOfStatement.h +++ b/ets2panda/ir/statements/forOfStatement.h @@ -77,6 +77,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/forUpdateStatement.cpp b/ets2panda/ir/statements/forUpdateStatement.cpp index 09ccc206027021f9ecad28e5c682212f9ad238f8..711632f31a19a1fee24212aea00f17c70f24811c 100644 --- a/ets2panda/ir/statements/forUpdateStatement.cpp +++ b/ets2panda/ir/statements/forUpdateStatement.cpp @@ -14,6 +14,7 @@ */ #include "forUpdateStatement.h" +#include #include "varbinder/scope.h" #include "compiler/base/condition.h" @@ -23,6 +24,8 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/dynamicContext.h" #include "checker/TSchecker.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ForUpdateStatement::TransformChildren(const NodeTransformer &cb) @@ -66,6 +69,33 @@ void ForUpdateStatement::Dump(ir::AstDumper *dumper) const {"body", body_}}); } +void ForUpdateStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("for "); + dumper->Add("("); + if (init_ != nullptr) { + init_->Dump(dumper); + } + dumper->Add(";"); + if (test_ != nullptr) { + test_->Dump(dumper); + } + dumper->Add(";"); + if (update_ != nullptr) { + update_->Dump(dumper); + } + dumper->Add(") "); + dumper->Add("{"); + if (body_ != nullptr) { + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("}"); +} + void ForUpdateStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/forUpdateStatement.h b/ets2panda/ir/statements/forUpdateStatement.h index 03e828ba1bda0d6882bf50181741f294f76981c9..fc4dfcc847db0adceda626e24f35ae4c5c3b707f 100644 --- a/ets2panda/ir/statements/forUpdateStatement.h +++ b/ets2panda/ir/statements/forUpdateStatement.h @@ -82,6 +82,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/functionDeclaration.cpp b/ets2panda/ir/statements/functionDeclaration.cpp index a5c9e3a6148b417654cc2360ad5ad0b80fc3934d..b3e2292424c8d59edf17cdc749114f117cf71876 100644 --- a/ets2panda/ir/statements/functionDeclaration.cpp +++ b/ets2panda/ir/statements/functionDeclaration.cpp @@ -19,6 +19,8 @@ #include "varbinder/scope.h" #include "compiler/core/ETSGen.h" #include "checker/TSchecker.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" #include "compiler/core/pandagen.h" namespace panda::es2panda::ir { @@ -47,6 +49,11 @@ void FunctionDeclaration::Dump(ir::AstDumper *dumper) const {"function", func_}}); } +void FunctionDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("FunctionDeclaration"); +} + void FunctionDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/functionDeclaration.h b/ets2panda/ir/statements/functionDeclaration.h index 449be13118f72f3a7629e4192bb18f5cc7df68f5..5437f2c3a1c50837439a5194bb6b02d518c296f0 100644 --- a/ets2panda/ir/statements/functionDeclaration.h +++ b/ets2panda/ir/statements/functionDeclaration.h @@ -59,6 +59,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/ifStatement.cpp b/ets2panda/ir/statements/ifStatement.cpp index 05b30ac4114a462e1148d45887c8a54fea6758d4..44e8b575713375281ebe90c4cb4e120712762ae5 100644 --- a/ets2panda/ir/statements/ifStatement.cpp +++ b/ets2panda/ir/statements/ifStatement.cpp @@ -14,10 +14,13 @@ */ #include "ifStatement.h" +#include #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void IfStatement::TransformChildren(const NodeTransformer &cb) @@ -48,6 +51,36 @@ void IfStatement::Dump(ir::AstDumper *dumper) const {"alternate", AstDumper::Nullish(alternate_)}}); } +void IfStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(test_); + dumper->Add("if ("); + test_->Dump(dumper); + dumper->Add(") {"); + if (consequent_ != nullptr) { + dumper->IncrIndent(); + dumper->Endl(); + dumper->DecrIndent(); + consequent_->Dump(dumper); + dumper->Endl(); + } + dumper->Add("}"); + if (alternate_ != nullptr) { + dumper->Add(" else "); + if (alternate_->IsBlockStatement()) { + dumper->Add("{"); + dumper->IncrIndent(); + dumper->Endl(); + dumper->DecrIndent(); + alternate_->Dump(dumper); + dumper->Endl(); + dumper->Add("}"); + } else { + alternate_->Dump(dumper); + } + } +} + void IfStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/ifStatement.h b/ets2panda/ir/statements/ifStatement.h index 70f0f2c9d2403c8dca597cfa58f183dbd60de076..0671a827f6c10cf7ef35f46ad45ad686d3f63e1d 100644 --- a/ets2panda/ir/statements/ifStatement.h +++ b/ets2panda/ir/statements/ifStatement.h @@ -70,6 +70,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/labelledStatement.cpp b/ets2panda/ir/statements/labelledStatement.cpp index c43d30ebf809b61b750156899434574fa474ec94..f74131e620e67faf1fbf6c842489631fe2a74a36 100644 --- a/ets2panda/ir/statements/labelledStatement.cpp +++ b/ets2panda/ir/statements/labelledStatement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void LabelledStatement::TransformChildren(const NodeTransformer &cb) @@ -37,6 +39,15 @@ void LabelledStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "LabelledStatement"}, {"label", ident_}, {"body", body_}}); } +void LabelledStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(ident_ != nullptr); + ident_->Dump(dumper); + dumper->Add(":"); + dumper->Endl(); + body_->Dump(dumper); +} + const ir::AstNode *LabelledStatement::GetReferencedStatement() const { const auto *iter = body_; diff --git a/ets2panda/ir/statements/labelledStatement.h b/ets2panda/ir/statements/labelledStatement.h index 28046f2fa365d6590ba0bd70cd75873688fafbf2..bb74240f40eab3d5da2d2bdbbe7c05d05ff3c0bc 100644 --- a/ets2panda/ir/statements/labelledStatement.h +++ b/ets2panda/ir/statements/labelledStatement.h @@ -58,6 +58,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/returnStatement.cpp b/ets2panda/ir/statements/returnStatement.cpp index fed52f836bfa29819bc1d99258983482caef2388..7991bfa0285ee970138a995ba7e3d586c6f38dc9 100644 --- a/ets2panda/ir/statements/returnStatement.cpp +++ b/ets2panda/ir/statements/returnStatement.cpp @@ -19,6 +19,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void ReturnStatement::TransformChildren(const NodeTransformer &cb) @@ -40,6 +41,16 @@ void ReturnStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ReturnStatement"}, {"argument", AstDumper::Nullish(argument_)}}); } +void ReturnStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("return"); + if (argument_ != nullptr) { + dumper->Add(" "); + argument_->Dump(dumper); + } + dumper->Add(";"); +} + void ReturnStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/returnStatement.h b/ets2panda/ir/statements/returnStatement.h index 853afc710af5b7c4088891b93639dcaf07f4a4f6..9c6be39dc5cd5daa82560c3c3f10a0587cbfe87f 100644 --- a/ets2panda/ir/statements/returnStatement.h +++ b/ets2panda/ir/statements/returnStatement.h @@ -66,6 +66,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/switchCaseStatement.cpp b/ets2panda/ir/statements/switchCaseStatement.cpp index 3830c777c6445b27e21d45b8b7069cbdda0e9a73..b8fe7a025fd8f56520802d346527b06d496e4f29 100644 --- a/ets2panda/ir/statements/switchCaseStatement.cpp +++ b/ets2panda/ir/statements/switchCaseStatement.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void SwitchCaseStatement::TransformChildren(const NodeTransformer &cb) @@ -47,6 +49,25 @@ void SwitchCaseStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "SwitchCase"}, {"test", AstDumper::Nullish(test_)}, {"consequent", consequent_}}); } +void SwitchCaseStatement::Dump(ir::SrcDumper *dumper) const +{ + if (test_ != nullptr) { + dumper->Add("case "); + test_->Dump(dumper); + dumper->Add(":"); + } else { + dumper->Add("default:"); + } + if (!consequent_.empty()) { + dumper->IncrIndent(); + dumper->Endl(); + for (auto cs : consequent_) { + cs->Dump(dumper); + } + dumper->DecrIndent(); + } +} + void SwitchCaseStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/switchCaseStatement.h b/ets2panda/ir/statements/switchCaseStatement.h index 43022283de3aaec74ed7d30fb99bc0d81f6a5371..3997c92d5195597411da19ef93a958283a5a2937 100644 --- a/ets2panda/ir/statements/switchCaseStatement.h +++ b/ets2panda/ir/statements/switchCaseStatement.h @@ -55,6 +55,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/switchStatement.cpp b/ets2panda/ir/statements/switchStatement.cpp index c7d908bd2d4ec163e47ee390b1a21ce49cb6b864..5c56c170d8b253a033e63446b13a8776638f9910 100644 --- a/ets2panda/ir/statements/switchStatement.cpp +++ b/ets2panda/ir/statements/switchStatement.cpp @@ -21,6 +21,8 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "checker/TSchecker.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void SwitchStatement::TransformChildren(const NodeTransformer &cb) @@ -46,6 +48,26 @@ void SwitchStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "SwitchStatement"}, {"discriminant", discriminant_}, {"cases", cases_}}); } +void SwitchStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(discriminant_); + dumper->Add("switch ("); + discriminant_->Dump(dumper); + dumper->Add(") {"); + if (!cases_.empty()) { + dumper->IncrIndent(); + dumper->Endl(); + for (auto cs : cases_) { + cs->Dump(dumper); + if (cs == cases_.back()) { + dumper->DecrIndent(); + } + dumper->Endl(); + } + } + dumper->Add("}"); +} + void SwitchStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/switchStatement.h b/ets2panda/ir/statements/switchStatement.h index 8a4b86b2b4c242f1062b0dad699e8e6dcbdea866..6b14aab08feb6550b9baa884956f144cebbd8b36 100644 --- a/ets2panda/ir/statements/switchStatement.h +++ b/ets2panda/ir/statements/switchStatement.h @@ -79,6 +79,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/throwStatement.cpp b/ets2panda/ir/statements/throwStatement.cpp index 28a3e2f54b1bbb6ce116c9c6bac617044b8ad53d..5ac70ad69f259546e332888092e491138e090770 100644 --- a/ets2panda/ir/statements/throwStatement.cpp +++ b/ets2panda/ir/statements/throwStatement.cpp @@ -19,6 +19,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" namespace panda::es2panda::ir { @@ -37,6 +38,14 @@ void ThrowStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "ThrowStatement"}, {"argument", argument_}}); } +void ThrowStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(Argument() != nullptr); + dumper->Add("throw "); + Argument()->Dump(dumper); + dumper->Add(";"); +} + void ThrowStatement::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/throwStatement.h b/ets2panda/ir/statements/throwStatement.h index 2a224ce2de5bbed253b871ab7e8def1cae37fed5..40e2b07704c8c8e1070bc89160e6114a580a3305 100644 --- a/ets2panda/ir/statements/throwStatement.h +++ b/ets2panda/ir/statements/throwStatement.h @@ -39,6 +39,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/tryStatement.cpp b/ets2panda/ir/statements/tryStatement.cpp index f325b681e959c93e98533dbeb08ac146cd2755cf..5c632f3ed5adda90eb981a690ab1aab78f491a91 100644 --- a/ets2panda/ir/statements/tryStatement.cpp +++ b/ets2panda/ir/statements/tryStatement.cpp @@ -21,6 +21,7 @@ #include "compiler/core/dynamicContext.h" #include "compiler/base/catchTable.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/catchClause.h" #include "ir/statements/blockStatement.h" @@ -59,6 +60,31 @@ void TryStatement::Dump(ir::AstDumper *dumper) const {"finalizer", AstDumper::Nullish(finalizer_)}}); } +void TryStatement::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(block_ != nullptr); + dumper->Add("try {"); + dumper->IncrIndent(); + dumper->Endl(); + block_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + dumper->Add("}"); + for (auto clause : catch_clauses_) { + dumper->Add(" catch "); + clause->Dump(dumper); + } + if (finalizer_ != nullptr) { + dumper->Add(" finally {"); + dumper->IncrIndent(); + dumper->Endl(); + finalizer_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + dumper->Add("}"); + } +} + bool TryStatement::HasDefaultCatchClause() const { return (!catch_clauses_.empty() && catch_clauses_.back()->IsDefaultCatchClause()); diff --git a/ets2panda/ir/statements/tryStatement.h b/ets2panda/ir/statements/tryStatement.h index 9661f2748a9e4d1ee33a9dc828d928b99a6be313..b60333579f7e1c6e144537a15d95da0674c44bce 100644 --- a/ets2panda/ir/statements/tryStatement.h +++ b/ets2panda/ir/statements/tryStatement.h @@ -87,6 +87,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/variableDeclaration.cpp b/ets2panda/ir/statements/variableDeclaration.cpp index 205265a3dafd8785ea6f8598622548db1514b8cc..91c56499328bdf31abef0edae504a6bfdf5876c2 100644 --- a/ets2panda/ir/statements/variableDeclaration.cpp +++ b/ets2panda/ir/statements/variableDeclaration.cpp @@ -15,6 +15,7 @@ #include "variableDeclaration.h" +#include "macros.h" #include "varbinder/scope.h" #include "varbinder/variable.h" #include "checker/TSchecker.h" @@ -22,6 +23,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/decorator.h" #include "ir/expressions/arrayExpression.h" #include "ir/expressions/identifier.h" @@ -80,6 +82,34 @@ void VariableDeclaration::Dump(ir::AstDumper *dumper) const {"declare", AstDumper::Optional(declare_)}}); } +void VariableDeclaration::Dump(ir::SrcDumper *dumper) const +{ + switch (kind_) { + case VariableDeclarationKind::CONST: + dumper->Add("const "); + break; + case VariableDeclarationKind::LET: + dumper->Add("let "); + break; + case VariableDeclarationKind::VAR: + dumper->Add("var "); + break; + default: + UNREACHABLE(); + } + + for (auto declarator : declarators_) { + declarator->Dump(dumper); + if (declarator != declarators_.back()) { + dumper->Add(", "); + } + } + + if ((parent_ != nullptr) && (parent_->IsBlockStatement() || parent_->IsBlockExpression())) { + dumper->Add(";"); + } +} + void VariableDeclaration::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/variableDeclaration.h b/ets2panda/ir/statements/variableDeclaration.h index 9b9fc3fcd9b53c35304313b43e114d66ca65f070..88e45ffe6433e3c0c27facd28cb0948794cde5ad 100644 --- a/ets2panda/ir/statements/variableDeclaration.h +++ b/ets2panda/ir/statements/variableDeclaration.h @@ -73,6 +73,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/variableDeclarator.cpp b/ets2panda/ir/statements/variableDeclarator.cpp index 3089bfd1cb17ff13b661abd5392bbed2c91555b8..7dc9140ded2c51bf09f95a80da56fe31dc90af3b 100644 --- a/ets2panda/ir/statements/variableDeclarator.cpp +++ b/ets2panda/ir/statements/variableDeclarator.cpp @@ -20,6 +20,7 @@ #include "compiler/core/pandagen.h" #include "compiler/core/ETSGen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/astNode.h" #include "ir/typeNode.h" #include "ir/expression.h" @@ -56,6 +57,24 @@ void VariableDeclarator::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "VariableDeclarator"}, {"id", id_}, {"init", AstDumper::Nullish(init_)}}); } +void VariableDeclarator::Dump(ir::SrcDumper *dumper) const +{ + if (id_ != nullptr) { + id_->Dump(dumper); + if (id_->IsAnnotatedExpression()) { + auto *type = id_->AsAnnotatedExpression()->TypeAnnotation(); + if (type != nullptr) { + dumper->Add(": "); + type->Dump(dumper); + } + } + } + if (init_ != nullptr) { + dumper->Add(" = "); + init_->Dump(dumper); + } +} + void VariableDeclarator::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/variableDeclarator.h b/ets2panda/ir/statements/variableDeclarator.h index 03cc256e9d7159a8e9090470916843647e82e267..aad932d74b896a8180d7983414636e2ca10a43ca 100644 --- a/ets2panda/ir/statements/variableDeclarator.h +++ b/ets2panda/ir/statements/variableDeclarator.h @@ -74,6 +74,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/statements/whileStatement.cpp b/ets2panda/ir/statements/whileStatement.cpp index 5624fd56d4d6aae09ac5f7bc615a6706952b3fda..5ab1715c5bda30ec806c31d865849a2149b2710f 100644 --- a/ets2panda/ir/statements/whileStatement.cpp +++ b/ets2panda/ir/statements/whileStatement.cpp @@ -23,6 +23,7 @@ #include "compiler/core/regScope.h" #include "checker/TSchecker.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" namespace panda::es2panda::ir { @@ -43,6 +44,23 @@ void WhileStatement::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "WhileStatement"}, {"test", test_}, {"body", body_}}); } +void WhileStatement::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("while ("); + if (test_ != nullptr) { + test_->Dump(dumper); + } + dumper->Add(") {"); + if (body_ != nullptr) { + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("}"); +} + void WhileStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/statements/whileStatement.h b/ets2panda/ir/statements/whileStatement.h index c4936cced5e3cd32307bcbfe1342b02a633f9cf4..85bbfc03968dcdd0151724693473c964dc3e635c 100644 --- a/ets2panda/ir/statements/whileStatement.h +++ b/ets2panda/ir/statements/whileStatement.h @@ -62,6 +62,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsAnyKeyword.cpp b/ets2panda/ir/ts/tsAnyKeyword.cpp index c82f0274154bba1664f4055ba3082a96504a8266..10a4645c5faacfe67bb10856727d6c44aaecce39 100644 --- a/ets2panda/ir/ts/tsAnyKeyword.cpp +++ b/ets2panda/ir/ts/tsAnyKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSAnyKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSAnyKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSAnyKeyword"}}); } +void TSAnyKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSAnyKeyword"); +} + void TSAnyKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsAnyKeyword.h b/ets2panda/ir/ts/tsAnyKeyword.h index 8fd327a711f0b1e3d6006614b12f9ee5a0a41a40..7eacc23c22b8caab206c83b6b761bb1fe479b755 100644 --- a/ets2panda/ir/ts/tsAnyKeyword.h +++ b/ets2panda/ir/ts/tsAnyKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsArrayType.cpp b/ets2panda/ir/ts/tsArrayType.cpp index 7233ca4ab5629f7689c2f7df9572fd7216b72ab5..ada705e56203e33a69f74ad974db12899f8a053a 100644 --- a/ets2panda/ir/ts/tsArrayType.cpp +++ b/ets2panda/ir/ts/tsArrayType.cpp @@ -18,8 +18,10 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" #include "checker/ETSchecker.h" +#include "macros.h" namespace panda::es2panda::ir { void TSArrayType::TransformChildren(const NodeTransformer &cb) @@ -37,6 +39,13 @@ void TSArrayType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSArrayType"}, {"elementType", element_type_}}); } +void TSArrayType::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(element_type_); + element_type_->Dump(dumper); + dumper->Add("[]"); +} + void TSArrayType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsArrayType.h b/ets2panda/ir/ts/tsArrayType.h index 96650e8492797fa8e3efda2b1f47888dab522275..48af2bfa6fcc964c1575f32ec464947c36bc4e9f 100644 --- a/ets2panda/ir/ts/tsArrayType.h +++ b/ets2panda/ir/ts/tsArrayType.h @@ -40,6 +40,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsAsExpression.cpp b/ets2panda/ir/ts/tsAsExpression.cpp index faeaf45c3cb25c776ed31810b459c97f56d78086..051d18b7a501ad7c7ffb506028571cc785f713ef 100644 --- a/ets2panda/ir/ts/tsAsExpression.cpp +++ b/ets2panda/ir/ts/tsAsExpression.cpp @@ -58,6 +58,11 @@ void TSAsExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSAsExpression"}, {"expression", expression_}, {"typeAnnotation", TypeAnnotation()}}); } +void TSAsExpression::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSAsExpression"); +} + void TSAsExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsAsExpression.h b/ets2panda/ir/ts/tsAsExpression.h index 0a75f58a3e6da525687b0abc9be8bdbfcb537894..2f48ec8e7f77eafd4b23aeb4c51514cb214377e6 100644 --- a/ets2panda/ir/ts/tsAsExpression.h +++ b/ets2panda/ir/ts/tsAsExpression.h @@ -17,6 +17,7 @@ #define ES2PANDA_IR_TS_AS_EXPRESSION_H #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" namespace panda::es2panda::checker { class ETSAnalyzer; @@ -53,6 +54,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsBigintKeyword.cpp b/ets2panda/ir/ts/tsBigintKeyword.cpp index baa374d6690499b117dd1e3f6a60a62c8c8d1d0d..e100389d0e6c71508e230ca191813496dcfd94f5 100644 --- a/ets2panda/ir/ts/tsBigintKeyword.cpp +++ b/ets2panda/ir/ts/tsBigintKeyword.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" namespace panda::es2panda::ir { @@ -30,6 +31,11 @@ void TSBigintKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSBigIntKeyword"}}); } +void TSBigintKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSBigintKeyword"); +} + void TSBigintKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsBigintKeyword.h b/ets2panda/ir/ts/tsBigintKeyword.h index 1baa67e14a33e7e5e680f195e8dcc4daa42aaa5e..8db316915b7c816a9aa13ada013c205ca52eb562 100644 --- a/ets2panda/ir/ts/tsBigintKeyword.h +++ b/ets2panda/ir/ts/tsBigintKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsBooleanKeyword.cpp b/ets2panda/ir/ts/tsBooleanKeyword.cpp index 7cc031e8a91543cfcef2b0a1a680ad182a2c90bc..7ef07bc9f1fa81c3cef2354c9ad75132caad8180 100644 --- a/ets2panda/ir/ts/tsBooleanKeyword.cpp +++ b/ets2panda/ir/ts/tsBooleanKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSBooleanKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSBooleanKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSBooleanKeyword"}}); } +void TSBooleanKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSBooleanKeyword"); +} + void TSBooleanKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsBooleanKeyword.h b/ets2panda/ir/ts/tsBooleanKeyword.h index 89f96ce9de87ad65a76912164e2eab5e126ffaae..e76373d8cfa1e81d0a8b814584664d560475444b 100644 --- a/ets2panda/ir/ts/tsBooleanKeyword.h +++ b/ets2panda/ir/ts/tsBooleanKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsClassImplements.cpp b/ets2panda/ir/ts/tsClassImplements.cpp index c3183cd25093eda04580e08ec958ed837f69c9dc..17d0cca22f34afced004c402c4534f892bf98ce5 100644 --- a/ets2panda/ir/ts/tsClassImplements.cpp +++ b/ets2panda/ir/ts/tsClassImplements.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ts/tsTypeParameter.h" #include "ir/ts/tsTypeParameterInstantiation.h" @@ -44,6 +45,12 @@ void TSClassImplements::Dump(ir::AstDumper *dumper) const {"typeParameters", AstDumper::Optional(type_parameters_)}}); } +void TSClassImplements::Dump(ir::SrcDumper *dumper) const +{ + expression_->Dump(dumper); + ASSERT(type_parameters_ == nullptr); +} + void TSClassImplements::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsClassImplements.h b/ets2panda/ir/ts/tsClassImplements.h index 49be88236acf1013f84fae72653a71be6d5377b5..32e9db6a65f328b1073dad19a370aac53576ad60 100644 --- a/ets2panda/ir/ts/tsClassImplements.h +++ b/ets2panda/ir/ts/tsClassImplements.h @@ -51,6 +51,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsConditionalType.cpp b/ets2panda/ir/ts/tsConditionalType.cpp index dc194f4b9cd1c0cf6687ed3a1fbd2980a9748423..e77f35e80a10c45eda051727291d7f306895a20b 100644 --- a/ets2panda/ir/ts/tsConditionalType.cpp +++ b/ets2panda/ir/ts/tsConditionalType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSConditionalType::TransformChildren(const NodeTransformer &cb) @@ -46,6 +47,11 @@ void TSConditionalType::Dump(ir::AstDumper *dumper) const {"falseType", false_type_}}); } +void TSConditionalType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSConditionalType"); +} + void TSConditionalType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsConditionalType.h b/ets2panda/ir/ts/tsConditionalType.h index c2c4d39a0c8f1d620027f58d6a7657c628813115..b309ba4ef2a367e953efa2d80e1bae95dc811dcf 100644 --- a/ets2panda/ir/ts/tsConditionalType.h +++ b/ets2panda/ir/ts/tsConditionalType.h @@ -54,6 +54,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsConstructorType.cpp b/ets2panda/ir/ts/tsConstructorType.cpp index 70c08d67f79558f8424fa428b61ac235fc1764ab..585639f82b1d845e857d33159a4a6b60051273fe 100644 --- a/ets2panda/ir/ts/tsConstructorType.cpp +++ b/ets2panda/ir/ts/tsConstructorType.cpp @@ -21,6 +21,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ts/tsTypeParameter.h" #include "ir/ts/tsTypeParameterDeclaration.h" @@ -44,6 +45,11 @@ void TSConstructorType::Dump(ir::AstDumper *dumper) const {"abstract", AstDumper::Optional(abstract_)}}); } +void TSConstructorType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSConstructorType"); +} + void TSConstructorType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsConstructorType.h b/ets2panda/ir/ts/tsConstructorType.h index 07a1564d563f73d98225fc12c4ae49df9a54e9ba..f126b33bd8fcda8113a833275a6fcd745b64573e 100644 --- a/ets2panda/ir/ts/tsConstructorType.h +++ b/ets2panda/ir/ts/tsConstructorType.h @@ -83,6 +83,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsEnumDeclaration.cpp b/ets2panda/ir/ts/tsEnumDeclaration.cpp index b0f73788e5517e4142ff969721f057e92825a6e0..426c5e9b1331540164e42c734498afdfda947f10 100644 --- a/ets2panda/ir/ts/tsEnumDeclaration.cpp +++ b/ets2panda/ir/ts/tsEnumDeclaration.cpp @@ -20,6 +20,8 @@ #include "compiler/core/pandagen.h" #include "varbinder/scope.h" #include "util/helpers.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSEnumDeclaration::TransformChildren(const NodeTransformer &cb) @@ -57,6 +59,30 @@ void TSEnumDeclaration::Dump(ir::AstDumper *dumper) const {"const", is_const_}}); } +void TSEnumDeclaration::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(is_const_ == false); + ASSERT(key_ != nullptr); + dumper->Add("enum "); + key_->Dump(dumper); + dumper->Add(" {"); + if (!members_.empty()) { + dumper->IncrIndent(); + dumper->Endl(); + for (auto member : members_) { + member->Dump(dumper); + if (member != members_.back()) { + dumper->Add(","); + dumper->Endl(); + } + } + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("}"); + dumper->Endl(); +} + // NOTE (csabahurton): this method has not been moved to TSAnalyizer.cpp, because it is not used. varbinder::EnumMemberResult EvaluateMemberExpression(checker::TSChecker *checker, [[maybe_unused]] varbinder::EnumVariable *enum_var, diff --git a/ets2panda/ir/ts/tsEnumDeclaration.h b/ets2panda/ir/ts/tsEnumDeclaration.h index 94fa10e7e3dba7de3c2b16f14037be6e5709cdb4..a0d0c168b6afb63b6b6979801f32fbb9a6aa9d5a 100644 --- a/ets2panda/ir/ts/tsEnumDeclaration.h +++ b/ets2panda/ir/ts/tsEnumDeclaration.h @@ -113,6 +113,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsEnumMember.cpp b/ets2panda/ir/ts/tsEnumMember.cpp index adb6873dd8b5ffb09e1c3451e10afe28b93c95ba..c08cafd9711fecbfe7021785e5b40f9cc6088040 100644 --- a/ets2panda/ir/ts/tsEnumMember.cpp +++ b/ets2panda/ir/ts/tsEnumMember.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSEnumMember::TransformChildren(const NodeTransformer &cb) @@ -43,6 +45,16 @@ void TSEnumMember::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSEnumMember"}, {"id", key_}, {"initializer", AstDumper::Optional(init_)}}); } +void TSEnumMember::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(key_ != nullptr); + key_->Dump(dumper); + if (init_ != nullptr) { + dumper->Add(" = "); + init_->Dump(dumper); + } +} + util::StringView TSEnumMember::Name() const { ASSERT(key_->IsIdentifier()); diff --git a/ets2panda/ir/ts/tsEnumMember.h b/ets2panda/ir/ts/tsEnumMember.h index 2d73dcabc769ddfebce58c3e66fb3ba2e5316f1e..c4bfbf3e7103f83e4349df40e0ec62c7ebc263b5 100644 --- a/ets2panda/ir/ts/tsEnumMember.h +++ b/ets2panda/ir/ts/tsEnumMember.h @@ -48,6 +48,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsExternalModuleReference.cpp b/ets2panda/ir/ts/tsExternalModuleReference.cpp index 601c235a021631515e75a58bcc15a6f566762db8..dc66c7fddc9e5a07284f768676c1a1e664ead117 100644 --- a/ets2panda/ir/ts/tsExternalModuleReference.cpp +++ b/ets2panda/ir/ts/tsExternalModuleReference.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSExternalModuleReference::TransformChildren(const NodeTransformer &cb) @@ -35,6 +37,11 @@ void TSExternalModuleReference::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSExternalModuleReference"}, {"expression", expr_}}); } +void TSExternalModuleReference::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSExternalModuleReference"); +} + void TSExternalModuleReference::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsExternalModuleReference.h b/ets2panda/ir/ts/tsExternalModuleReference.h index 51234fdb8e5afa89f03bcc97631217f29630d8e2..3bc8f845370368d1aaf8c91d65841a6b57f172a8 100644 --- a/ets2panda/ir/ts/tsExternalModuleReference.h +++ b/ets2panda/ir/ts/tsExternalModuleReference.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsFunctionType.cpp b/ets2panda/ir/ts/tsFunctionType.cpp index bcd5f1b1a80b1748a4273881e9201706ba6de3f5..03e1601743133f9ad1204409d61380b8e997b03d 100644 --- a/ets2panda/ir/ts/tsFunctionType.cpp +++ b/ets2panda/ir/ts/tsFunctionType.cpp @@ -22,6 +22,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/spreadElement.h" #include "ir/expressions/identifier.h" #include "ir/ts/tsTypeParameter.h" @@ -47,6 +48,11 @@ void TSFunctionType::Dump(ir::AstDumper *dumper) const {"isNullable", AstDumper::Optional(nullable_)}}); } +void TSFunctionType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSFunctionType"); +} + void TSFunctionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsFunctionType.h b/ets2panda/ir/ts/tsFunctionType.h index 596809351a395fb8c5a60002ee2fbba93ac493dc..a9b6401f5fbdbaf1f5d1df09a9cfdc05b8ecf8c4 100644 --- a/ets2panda/ir/ts/tsFunctionType.h +++ b/ets2panda/ir/ts/tsFunctionType.h @@ -81,6 +81,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsImportEqualsDeclaration.cpp b/ets2panda/ir/ts/tsImportEqualsDeclaration.cpp index 3f08423270aaf6035b71c4e422312f5bf79acd15..3250853b953eb72f44dd231f564ab81f32f64993 100644 --- a/ets2panda/ir/ts/tsImportEqualsDeclaration.cpp +++ b/ets2panda/ir/ts/tsImportEqualsDeclaration.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" #include "ir/expressions/identifier.h" @@ -43,6 +44,11 @@ void TSImportEqualsDeclaration::Dump(ir::AstDumper *dumper) const {"isExport", is_export_}}); } +void TSImportEqualsDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSImportEqualsDeclaration"); +} + void TSImportEqualsDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsImportEqualsDeclaration.h b/ets2panda/ir/ts/tsImportEqualsDeclaration.h index f4fff48ffe3c319988857d2d21a805e318eb6643..70b6fc99586c565a897066556d28b3e556ed1150 100644 --- a/ets2panda/ir/ts/tsImportEqualsDeclaration.h +++ b/ets2panda/ir/ts/tsImportEqualsDeclaration.h @@ -49,6 +49,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsImportType.cpp b/ets2panda/ir/ts/tsImportType.cpp index 316ba0551154e56b010124d5e1fdd61efabd044d..a3f5c89f58fdfcf763cd61c85ea7444b0cc5122a 100644 --- a/ets2panda/ir/ts/tsImportType.cpp +++ b/ets2panda/ir/ts/tsImportType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ts/tsTypeParameter.h" #include "ir/ts/tsTypeParameterInstantiation.h" @@ -58,6 +59,11 @@ void TSImportType::Dump(ir::AstDumper *dumper) const {"isTypeOf", is_typeof_}}); } +void TSImportType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSImportType"); +} + void TSImportType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsImportType.h b/ets2panda/ir/ts/tsImportType.h index 2c182abd5953c3d6eebd8a2591ee75166cadacde..bf48f27d4ecbb39550b96d1dc7f5cf4e7b27f10d 100644 --- a/ets2panda/ir/ts/tsImportType.h +++ b/ets2panda/ir/ts/tsImportType.h @@ -56,6 +56,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsIndexedAccessType.cpp b/ets2panda/ir/ts/tsIndexedAccessType.cpp index 22d534af67ca2e7c2ba32f4340e059482c1fc213..cf48ba907b33157f126850573031d025f098be76 100644 --- a/ets2panda/ir/ts/tsIndexedAccessType.cpp +++ b/ets2panda/ir/ts/tsIndexedAccessType.cpp @@ -18,6 +18,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" @@ -39,6 +40,11 @@ void TSIndexedAccessType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSIndexedAccessType"}, {"objectType", object_type_}, {"indexType", index_type_}}); } +void TSIndexedAccessType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSIndexedAccessType"); +} + void TSIndexedAccessType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsIndexedAccessType.h b/ets2panda/ir/ts/tsIndexedAccessType.h index ab7a43f9a4bab695c0c0a9a9784006700f13bfa6..d3f0154513ed6937f23bfa26da038b68e660a20e 100644 --- a/ets2panda/ir/ts/tsIndexedAccessType.h +++ b/ets2panda/ir/ts/tsIndexedAccessType.h @@ -45,6 +45,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsInferType.cpp b/ets2panda/ir/ts/tsInferType.cpp index d108bb9540087e4571bec027eecfd970346b17c8..89c61ff68544ca56b2c61ffa1b9f872270477821 100644 --- a/ets2panda/ir/ts/tsInferType.cpp +++ b/ets2panda/ir/ts/tsInferType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ts/tsTypeParameter.h" namespace panda::es2panda::ir { @@ -37,6 +38,11 @@ void TSInferType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSInferType"}, {"typeParameter", type_param_}}); } +void TSInferType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSInferType"); +} + void TSInferType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsInferType.h b/ets2panda/ir/ts/tsInferType.h index 0609b12c9637ffb87052011c11c75aabb0360fcb..5f7023b99be5732b558b4124fae3c399bdc96e45 100644 --- a/ets2panda/ir/ts/tsInferType.h +++ b/ets2panda/ir/ts/tsInferType.h @@ -33,6 +33,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsInterfaceBody.cpp b/ets2panda/ir/ts/tsInterfaceBody.cpp index 418b66f22dfc2943db631cfbcaee60592f0be93f..ecdb20767258843ee742c126607d2a0c44bd21a3 100644 --- a/ets2panda/ir/ts/tsInterfaceBody.cpp +++ b/ets2panda/ir/ts/tsInterfaceBody.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSInterfaceBody::TransformChildren(const NodeTransformer &cb) @@ -40,6 +41,13 @@ void TSInterfaceBody::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSInterfaceBody"}, {"body", body_}}); } +void TSInterfaceBody::Dump(ir::SrcDumper *dumper) const +{ + for (auto b : body_) { + b->Dump(dumper); + } +} + void TSInterfaceBody::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsInterfaceBody.h b/ets2panda/ir/ts/tsInterfaceBody.h index 4e0396b934f2b1328034f59fe508a627def76b21..74bd7cc0ace68a143e68c8cbf6864ee57e60e5f6 100644 --- a/ets2panda/ir/ts/tsInterfaceBody.h +++ b/ets2panda/ir/ts/tsInterfaceBody.h @@ -44,6 +44,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsInterfaceDeclaration.cpp b/ets2panda/ir/ts/tsInterfaceDeclaration.cpp index 9dc4135dcef03f75145752a0ae9c485875a23d51..8aa2b8ebc9b91a66a9352a1a3be5240c5a122696 100644 --- a/ets2panda/ir/ts/tsInterfaceDeclaration.cpp +++ b/ets2panda/ir/ts/tsInterfaceDeclaration.cpp @@ -15,6 +15,7 @@ #include "tsInterfaceDeclaration.h" +#include "macros.h" #include "varbinder/declaration.h" #include "varbinder/scope.h" #include "varbinder/variable.h" @@ -23,6 +24,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/decorator.h" #include "ir/expressions/identifier.h" #include "ir/ts/tsInterfaceBody.h" @@ -79,6 +81,41 @@ void TSInterfaceDeclaration::Dump(ir::AstDumper *dumper) const {"typeParameters", AstDumper::Optional(type_params_)}}); } +void TSInterfaceDeclaration::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(id_); + + dumper->Add("interface "); + id_->Dump(dumper); + + if (type_params_ != nullptr) { + dumper->Add("<"); + type_params_->Dump(dumper); + dumper->Add(">"); + } + + if (!extends_.empty()) { + dumper->Add(" extends "); + for (auto ext : extends_) { + ext->Dump(dumper); + if (ext != extends_.back()) { + dumper->Add(", "); + } + } + } + + dumper->Add(" {"); + if (body_ != nullptr) { + dumper->IncrIndent(); + dumper->Endl(); + body_->Dump(dumper); + dumper->DecrIndent(); + dumper->Endl(); + } + dumper->Add("}"); + dumper->Endl(); +} + void TSInterfaceDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsInterfaceDeclaration.h b/ets2panda/ir/ts/tsInterfaceDeclaration.h index ce7d18f62257df6ccf5af444fe5fc5ec75e85422..832f9adb67b456bd1a29674508ad8bc6625ec666 100644 --- a/ets2panda/ir/ts/tsInterfaceDeclaration.h +++ b/ets2panda/ir/ts/tsInterfaceDeclaration.h @@ -154,6 +154,7 @@ public: void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsInterfaceHeritage.cpp b/ets2panda/ir/ts/tsInterfaceHeritage.cpp index e14e86ecaac7651ee823177a00c40e4943f35bd6..9346dde8c795e53a0207c8a60c7493d934ee73a2 100644 --- a/ets2panda/ir/ts/tsInterfaceHeritage.cpp +++ b/ets2panda/ir/ts/tsInterfaceHeritage.cpp @@ -14,6 +14,7 @@ */ #include "tsInterfaceHeritage.h" +#include #include "varbinder/scope.h" #include "checker/TSchecker.h" @@ -21,6 +22,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" #include "ir/ts/tsTypeParameterInstantiation.h" #include "ir/ts/tsTypeReference.h" @@ -44,6 +46,12 @@ void TSInterfaceHeritage::Dump(ir::AstDumper *dumper) const }); } +void TSInterfaceHeritage::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(expr_ != nullptr); + expr_->Dump(dumper); +} + void TSInterfaceHeritage::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsInterfaceHeritage.h b/ets2panda/ir/ts/tsInterfaceHeritage.h index c677b5a3598ae6f1132371c7f4103845e52f863e..5752c2ea127cb8253e288e1d2a7ff030429958e1 100644 --- a/ets2panda/ir/ts/tsInterfaceHeritage.h +++ b/ets2panda/ir/ts/tsInterfaceHeritage.h @@ -39,6 +39,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsIntersectionType.cpp b/ets2panda/ir/ts/tsIntersectionType.cpp index a25efa4371b2611fea732dc37e1ce2dd278bf8c0..42a0b7e16dbffca6193f7f16792360d34504e657 100644 --- a/ets2panda/ir/ts/tsIntersectionType.cpp +++ b/ets2panda/ir/ts/tsIntersectionType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/ETSchecker.h" namespace panda::es2panda::ir { @@ -41,6 +42,11 @@ void TSIntersectionType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSIntersectionType"}, {"types", types_}}); } +void TSIntersectionType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSIntersectionType"); +} + void TSIntersectionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsIntersectionType.h b/ets2panda/ir/ts/tsIntersectionType.h index 08e94c2a0e1d4302c2f0ecd70ca3bed25f54bf49..4c205273f046b6d14d58e00c97559aabf0e38178 100644 --- a/ets2panda/ir/ts/tsIntersectionType.h +++ b/ets2panda/ir/ts/tsIntersectionType.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsLiteralType.cpp b/ets2panda/ir/ts/tsLiteralType.cpp index 44d05c36f516a882d5a203942a870d6eadc0a5b6..ed241dc8d26150b3ab30cde2ff5bae8cc51307dd 100644 --- a/ets2panda/ir/ts/tsLiteralType.cpp +++ b/ets2panda/ir/ts/tsLiteralType.cpp @@ -18,6 +18,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" namespace panda::es2panda::ir { @@ -36,6 +37,11 @@ void TSLiteralType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSLiteralType"}, {"literal", literal_}}); } +void TSLiteralType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSLiteralType"); +} + void TSLiteralType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsLiteralType.h b/ets2panda/ir/ts/tsLiteralType.h index 44088e32cb927a6e39c076e90127b576126b0f69..b867c0e1b14840883acb50d103e3bf4213c61ac4 100644 --- a/ets2panda/ir/ts/tsLiteralType.h +++ b/ets2panda/ir/ts/tsLiteralType.h @@ -31,6 +31,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsMappedType.cpp b/ets2panda/ir/ts/tsMappedType.cpp index cb9c54072d10beec131d13ad3906b1f410c81ad8..ed00ebd1d8fd4d33f62b0e7e495f2660292958c0 100644 --- a/ets2panda/ir/ts/tsMappedType.cpp +++ b/ets2panda/ir/ts/tsMappedType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" #include "ir/ts/tsTypeParameter.h" @@ -52,6 +53,11 @@ void TSMappedType::Dump(ir::AstDumper *dumper) const : AstDumper::Optional("-")}}); } +void TSMappedType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSMappedType"); +} + void TSMappedType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsMappedType.h b/ets2panda/ir/ts/tsMappedType.h index 42d352b3a3c01b2242621500070879a20859d763..a073f939a0edcb089fd8dd731696cf49f0b3ccc0 100644 --- a/ets2panda/ir/ts/tsMappedType.h +++ b/ets2panda/ir/ts/tsMappedType.h @@ -55,6 +55,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsModuleBlock.cpp b/ets2panda/ir/ts/tsModuleBlock.cpp index 1b3443a72c8b68448e704a76dfe84cfdc75561fd..806d4282fd4990cc3a14ee101a757b4c2a53d89e 100644 --- a/ets2panda/ir/ts/tsModuleBlock.cpp +++ b/ets2panda/ir/ts/tsModuleBlock.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSModuleBlock::TransformChildren(const NodeTransformer &cb) @@ -41,6 +42,11 @@ void TSModuleBlock::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSModuleBlock"}, {"body", statements_}}); } +void TSModuleBlock::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSModuleBlock"); +} + void TSModuleBlock::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsModuleBlock.h b/ets2panda/ir/ts/tsModuleBlock.h index f6c512a94b8c80c2e2e7412bfdf7d7f9b0c514c1..e4eab3a1a3122f6ae92c254a17638ba57f43f2d5 100644 --- a/ets2panda/ir/ts/tsModuleBlock.h +++ b/ets2panda/ir/ts/tsModuleBlock.h @@ -50,6 +50,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsModuleDeclaration.cpp b/ets2panda/ir/ts/tsModuleDeclaration.cpp index 25ad9e6570e9bdf2044c4983f8fc51e3772b035a..7fe62de00c55e2431fdbbc927e55a2179692aa26 100644 --- a/ets2panda/ir/ts/tsModuleDeclaration.cpp +++ b/ets2panda/ir/ts/tsModuleDeclaration.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/base/decorator.h" #include "ir/expression.h" @@ -60,6 +61,11 @@ void TSModuleDeclaration::Dump(ir::AstDumper *dumper) const {"global", global_}}); } +void TSModuleDeclaration::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSModuleDeclaration"); +} + void TSModuleDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsModuleDeclaration.h b/ets2panda/ir/ts/tsModuleDeclaration.h index ba3aa58bbaf670ce41d675e6f7fb82212357501d..d2d5d0cf774ac56dfd73b450c9399d38c4de826c 100644 --- a/ets2panda/ir/ts/tsModuleDeclaration.h +++ b/ets2panda/ir/ts/tsModuleDeclaration.h @@ -89,6 +89,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsNamedTupleMember.cpp b/ets2panda/ir/ts/tsNamedTupleMember.cpp index bfea9f07de9f9dc64e229988c6414918ffc43d4c..5aec5d96fce8106d0b5bde5cb4be593b0c465775 100644 --- a/ets2panda/ir/ts/tsNamedTupleMember.cpp +++ b/ets2panda/ir/ts/tsNamedTupleMember.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSNamedTupleMember::TransformChildren(const NodeTransformer &cb) @@ -42,6 +43,11 @@ void TSNamedTupleMember::Dump(ir::AstDumper *dumper) const {"optional", AstDumper::Optional(optional_)}}); } +void TSNamedTupleMember::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSNamedTupleMember"); +} + void TSNamedTupleMember::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsNamedTupleMember.h b/ets2panda/ir/ts/tsNamedTupleMember.h index 8cec5e8617b07956fa698cb5448e59f51266abd8..28545cbb7f4f0965dea1ad8b92842630795adeb3 100644 --- a/ets2panda/ir/ts/tsNamedTupleMember.h +++ b/ets2panda/ir/ts/tsNamedTupleMember.h @@ -49,6 +49,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsNeverKeyword.cpp b/ets2panda/ir/ts/tsNeverKeyword.cpp index ee52a42c6b9b112dfa05c6ffbcdb6125fbcf0b5a..092d86ca89fd6f20a608adf79897d91645f59beb 100644 --- a/ets2panda/ir/ts/tsNeverKeyword.cpp +++ b/ets2panda/ir/ts/tsNeverKeyword.cpp @@ -18,6 +18,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" namespace panda::es2panda::ir { @@ -29,6 +30,11 @@ void TSNeverKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSNeverKeyword"}}); } +void TSNeverKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSNeverKeyword"); +} + void TSNeverKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsNeverKeyword.h b/ets2panda/ir/ts/tsNeverKeyword.h index 8df44f6a79745febc19104dc20857488bbf8ad42..948991fba6d2595bb90f1217fb355a02f6cc85bc 100644 --- a/ets2panda/ir/ts/tsNeverKeyword.h +++ b/ets2panda/ir/ts/tsNeverKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsNonNullExpression.cpp b/ets2panda/ir/ts/tsNonNullExpression.cpp index ac49f17ac8ae1bf8b21f7d09aac60c026cc46a87..7dc7a91a68a3472af3a4ab5f79f0c6944082ff46 100644 --- a/ets2panda/ir/ts/tsNonNullExpression.cpp +++ b/ets2panda/ir/ts/tsNonNullExpression.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSNonNullExpression::TransformChildren(const NodeTransformer &cb) @@ -37,6 +38,13 @@ void TSNonNullExpression::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSNonNullExpression"}, {"expression", expr_}}); } +void TSNonNullExpression::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(expr_ != nullptr); + expr_->Dump(dumper); + dumper->Add("!"); +} + void TSNonNullExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsNonNullExpression.h b/ets2panda/ir/ts/tsNonNullExpression.h index ebd95ca8f9f6fda9da520ee99d46b35ab0d04be7..1453a835d4e7527d5f9ef30361e144a5750aeba6 100644 --- a/ets2panda/ir/ts/tsNonNullExpression.h +++ b/ets2panda/ir/ts/tsNonNullExpression.h @@ -37,6 +37,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile([[maybe_unused]] compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsNullKeyword.cpp b/ets2panda/ir/ts/tsNullKeyword.cpp index 1ecd8382424dbc59c457fbed877881178e5524a4..6c380c67d3ab980f7c3724fd2f8a8fd227928c39 100644 --- a/ets2panda/ir/ts/tsNullKeyword.cpp +++ b/ets2panda/ir/ts/tsNullKeyword.cpp @@ -18,6 +18,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" namespace panda::es2panda::ir { @@ -29,6 +30,11 @@ void TSNullKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSNullKeyword"}}); } +void TSNullKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSNullKeyword"); +} + void TSNullKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsNullKeyword.h b/ets2panda/ir/ts/tsNullKeyword.h index 6f72575c7eb91a63b7db140fb86b243444e24ba5..5c87da2caf71d23486b706fc0162034abbf54276 100644 --- a/ets2panda/ir/ts/tsNullKeyword.h +++ b/ets2panda/ir/ts/tsNullKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsNumberKeyword.cpp b/ets2panda/ir/ts/tsNumberKeyword.cpp index 13aca3172f286fb496bf7b9cbaecaacd2f6cdb43..0a7259494a92ddbdb2b6d834b0e389e0847ab766 100644 --- a/ets2panda/ir/ts/tsNumberKeyword.cpp +++ b/ets2panda/ir/ts/tsNumberKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSNumberKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSNumberKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSNumberKeyword"}}); } +void TSNumberKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSNumberKeyword"); +} + void TSNumberKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsNumberKeyword.h b/ets2panda/ir/ts/tsNumberKeyword.h index 1b24a8696f7c39f7ff9886317c166a425dbc7e90..33257ae935820444e57c613e194018d783971d5f 100644 --- a/ets2panda/ir/ts/tsNumberKeyword.h +++ b/ets2panda/ir/ts/tsNumberKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsObjectKeyword.cpp b/ets2panda/ir/ts/tsObjectKeyword.cpp index da0fea006153b8aca88c0a39aecb43b9f7db034f..ccbfbb678e93f15cbb382fa06c8466fe5df4ad9b 100644 --- a/ets2panda/ir/ts/tsObjectKeyword.cpp +++ b/ets2panda/ir/ts/tsObjectKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSObjectKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSObjectKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSObjectKeyword"}}); } +void TSObjectKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSObjectKeyword"); +} + void TSObjectKeyword::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsObjectKeyword.h b/ets2panda/ir/ts/tsObjectKeyword.h index 2a1b328e6f51d81b2dd33c560ff4eaf70d51e69b..69f6c1ca9e5045f28090b923282893c8389d4e6e 100644 --- a/ets2panda/ir/ts/tsObjectKeyword.h +++ b/ets2panda/ir/ts/tsObjectKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsParameterProperty.cpp b/ets2panda/ir/ts/tsParameterProperty.cpp index 4f5cfd854a5e5408b0c0818b0562a41264efac1b..30917530425d5e6e5c722a0d47f018500432e0ae 100644 --- a/ets2panda/ir/ts/tsParameterProperty.cpp +++ b/ets2panda/ir/ts/tsParameterProperty.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" namespace panda::es2panda::ir { @@ -45,6 +46,11 @@ void TSParameterProperty::Dump(ir::AstDumper *dumper) const {"parameter", parameter_}}); } +void TSParameterProperty::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSParameterProperty"); +} + void TSParameterProperty::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsParameterProperty.h b/ets2panda/ir/ts/tsParameterProperty.h index 4144e57cb44baa0c96af68923ae779044d2cc2ef..9f8baa2b18f1c8e0d928bbd22b716610b84cac0a 100644 --- a/ets2panda/ir/ts/tsParameterProperty.h +++ b/ets2panda/ir/ts/tsParameterProperty.h @@ -63,6 +63,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsParenthesizedType.cpp b/ets2panda/ir/ts/tsParenthesizedType.cpp index 04012a2b20bb43aa0060e3eef2119ab9ea7bb8b3..d6e415dd19f93ef9a910c39c7a0ea98fbea055fb 100644 --- a/ets2panda/ir/ts/tsParenthesizedType.cpp +++ b/ets2panda/ir/ts/tsParenthesizedType.cpp @@ -18,6 +18,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" namespace panda::es2panda::ir { @@ -36,6 +37,11 @@ void TSParenthesizedType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSParenthesizedType"}, {"typeAnnotation", type_}}); } +void TSParenthesizedType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSParenthesizedType"); +} + void TSParenthesizedType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsParenthesizedType.h b/ets2panda/ir/ts/tsParenthesizedType.h index 1eac0852dc7459e95c906ac26efa33c2f31b3f49..61cf2ea527452a4e36efa32e859cbb54e325df1f 100644 --- a/ets2panda/ir/ts/tsParenthesizedType.h +++ b/ets2panda/ir/ts/tsParenthesizedType.h @@ -36,6 +36,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsQualifiedName.cpp b/ets2panda/ir/ts/tsQualifiedName.cpp index c9099debbde40ea9d58efeaf21ecdd026ec2cf55..d87a88409a2a5098ceb1d26714e41485040e1c66 100644 --- a/ets2panda/ir/ts/tsQualifiedName.cpp +++ b/ets2panda/ir/ts/tsQualifiedName.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" namespace panda::es2panda::ir { @@ -40,6 +41,11 @@ void TSQualifiedName::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSQualifiedName"}, {"left", left_}, {"right", right_}}); } +void TSQualifiedName::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSQualifiedName"); +} + void TSQualifiedName::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsQualifiedName.h b/ets2panda/ir/ts/tsQualifiedName.h index 7d00a524d5784456fffd58592fdb0db17552316c..a59bf6aa3a2fd7988ad27fd2e8de52b53817ea14 100644 --- a/ets2panda/ir/ts/tsQualifiedName.h +++ b/ets2panda/ir/ts/tsQualifiedName.h @@ -54,6 +54,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsStringKeyword.cpp b/ets2panda/ir/ts/tsStringKeyword.cpp index 11caf9ca5a439ab380ae10e48c43135243033167..b28c67c7b13653c2486b9a1a2dbb5ee5e36e7d62 100644 --- a/ets2panda/ir/ts/tsStringKeyword.cpp +++ b/ets2panda/ir/ts/tsStringKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSStringKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSStringKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSStringKeyword"}}); } +void TSStringKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSStringKeyword"); +} + void TSStringKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsStringKeyword.h b/ets2panda/ir/ts/tsStringKeyword.h index 9fe1030d0f8cf0ac4fb48de9ef556facecbc1cb2..18bd3c338b055206bb8e5162ebb1e8cc415593ca 100644 --- a/ets2panda/ir/ts/tsStringKeyword.h +++ b/ets2panda/ir/ts/tsStringKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsThisType.cpp b/ets2panda/ir/ts/tsThisType.cpp index 9827778d624a63a5faa7d69a5a3b5240ec7b3dba..e98bde61edfcd70f6aa6be905224b15f7798513f 100644 --- a/ets2panda/ir/ts/tsThisType.cpp +++ b/ets2panda/ir/ts/tsThisType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSThisType::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -29,6 +30,11 @@ void TSThisType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSThisType"}}); } +void TSThisType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSThisType"); +} + void TSThisType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsThisType.h b/ets2panda/ir/ts/tsThisType.h index 82e9f4062dc9a70944fe72c2c97fb4283ff5765b..bdf17136486572b2f487dd21fa913e1be78e41b9 100644 --- a/ets2panda/ir/ts/tsThisType.h +++ b/ets2panda/ir/ts/tsThisType.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTupleType.cpp b/ets2panda/ir/ts/tsTupleType.cpp index 624d9582339de06f529aec7f65d22778c9842f6f..80111e7c27556570f484e76e980f9458178acb8f 100644 --- a/ets2panda/ir/ts/tsTupleType.cpp +++ b/ets2panda/ir/ts/tsTupleType.cpp @@ -22,6 +22,7 @@ #include "checker/TSchecker.h" #include "checker/types/ts/indexInfo.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" #include "ir/ts/tsNamedTupleMember.h" @@ -45,6 +46,11 @@ void TSTupleType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSTupleType"}, {"elementTypes", element_types_}}); } +void TSTupleType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSTupleType"); +} + void TSTupleType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTupleType.h b/ets2panda/ir/ts/tsTupleType.h index 5cf53189dadeadeaf03073cf486019b30d71e369..c855bffec111b7f3d932da7ba77c1357d6d590a0 100644 --- a/ets2panda/ir/ts/tsTupleType.h +++ b/ets2panda/ir/ts/tsTupleType.h @@ -36,6 +36,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeAliasDeclaration.cpp b/ets2panda/ir/ts/tsTypeAliasDeclaration.cpp index 83bf379328b27f1fb35a5f84590a85d7ecb6d82e..aafa75994a91ed981a903a9f2f3fc633ef7e8c00 100644 --- a/ets2panda/ir/ts/tsTypeAliasDeclaration.cpp +++ b/ets2panda/ir/ts/tsTypeAliasDeclaration.cpp @@ -14,12 +14,15 @@ */ #include "tsTypeAliasDeclaration.h" +#include +#include "macros.h" #include "varbinder/scope.h" #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" #include "ir/base/decorator.h" #include "ir/expressions/identifier.h" @@ -71,6 +74,26 @@ void TSTypeAliasDeclaration::Dump(ir::AstDumper *dumper) const {"declare", AstDumper::Optional(declare_)}}); } +void TSTypeAliasDeclaration::Dump(ir::SrcDumper *dumper) const +{ + ASSERT(id_); + dumper->Add("type "); + id_->Dump(dumper); + if (type_params_ != nullptr) { + dumper->Add("<"); + type_params_->Dump(dumper); + dumper->Add(">"); + } + dumper->Add(" = "); + if (id_->IsAnnotatedExpression()) { + auto type = TypeAnnotation(); + ASSERT(type); + type->Dump(dumper); + } + dumper->Add(";"); + dumper->Endl(); +} + void TSTypeAliasDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeAliasDeclaration.h b/ets2panda/ir/ts/tsTypeAliasDeclaration.h index 5108c08e37c23a29448c5b9c5663ac550efe947b..9c4415dd5a00d0716340b10c786ec83b63ccaa03 100644 --- a/ets2panda/ir/ts/tsTypeAliasDeclaration.h +++ b/ets2panda/ir/ts/tsTypeAliasDeclaration.h @@ -95,6 +95,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeAssertion.cpp b/ets2panda/ir/ts/tsTypeAssertion.cpp index 2c2bd745e3e9bed7029869145b56bc9578a8d54a..15a20c7d09f28fb61eccfc895ad6be2fa9aa5a56 100644 --- a/ets2panda/ir/ts/tsTypeAssertion.cpp +++ b/ets2panda/ir/ts/tsTypeAssertion.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" namespace panda::es2panda::ir { @@ -39,6 +40,11 @@ void TSTypeAssertion::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSTypeAssertion"}, {"typeAnnotation", TypeAnnotation()}, {"expression", expression_}}); } +void TSTypeAssertion::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSTypeAssertion"); +} + void TSTypeAssertion::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeAssertion.h b/ets2panda/ir/ts/tsTypeAssertion.h index 90f2856ed402b9535f3e9f075479c256f7db5e2c..e06e81fa90c1d564e80f83e3337246abd0b4e57c 100644 --- a/ets2panda/ir/ts/tsTypeAssertion.h +++ b/ets2panda/ir/ts/tsTypeAssertion.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeLiteral.cpp b/ets2panda/ir/ts/tsTypeLiteral.cpp index 9f9471ab8fb7a9f39625d2f9b8eeb80f420333a7..c05861d2bd581a40580372ec0afed8dd566c79ca 100644 --- a/ets2panda/ir/ts/tsTypeLiteral.cpp +++ b/ets2panda/ir/ts/tsTypeLiteral.cpp @@ -18,6 +18,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "varbinder/variable.h" #include "varbinder/declaration.h" @@ -44,6 +45,11 @@ void TSTypeLiteral::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSTypeLiteral"}, {"members", members_}}); } +void TSTypeLiteral::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSTypeLiteral"); +} + void TSTypeLiteral::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeLiteral.h b/ets2panda/ir/ts/tsTypeLiteral.h index 773cae0061e25182c5cba84f7270bad3567f153c..9de5ba6811da6b42162b0855091cc307045ccd8c 100644 --- a/ets2panda/ir/ts/tsTypeLiteral.h +++ b/ets2panda/ir/ts/tsTypeLiteral.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeOperator.cpp b/ets2panda/ir/ts/tsTypeOperator.cpp index f945f6e43f3fccbac777ed96d7198f5d44a2dcb4..05aa4ef7277263100e9f6dfc8551228c7cd5de29 100644 --- a/ets2panda/ir/ts/tsTypeOperator.cpp +++ b/ets2panda/ir/ts/tsTypeOperator.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSTypeOperator::TransformChildren(const NodeTransformer &cb) @@ -40,6 +41,11 @@ void TSTypeOperator::Dump(ir::AstDumper *dumper) const }); } +void TSTypeOperator::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSTypeOperator"); +} + void TSTypeOperator::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeOperator.h b/ets2panda/ir/ts/tsTypeOperator.h index 921746337bd6cf530e3c86a00a173ea611a8735b..8c8266290228b4b6c0a166cdcd2f650245bb0d9c 100644 --- a/ets2panda/ir/ts/tsTypeOperator.h +++ b/ets2panda/ir/ts/tsTypeOperator.h @@ -49,6 +49,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeParameter.cpp b/ets2panda/ir/ts/tsTypeParameter.cpp index e464990af26f8ebd0bad98179ed160704bc00e1f..a16ad2100c837dcae9efb742929fd3bf1313300a 100644 --- a/ets2panda/ir/ts/tsTypeParameter.cpp +++ b/ets2panda/ir/ts/tsTypeParameter.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" #include "ir/expressions/identifier.h" @@ -61,6 +62,11 @@ void TSTypeParameter::Dump(ir::AstDumper *dumper) const }); } +void TSTypeParameter::Dump(ir::SrcDumper *dumper) const +{ + name_->Dump(dumper); +} + void TSTypeParameter::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeParameter.h b/ets2panda/ir/ts/tsTypeParameter.h index edcde8069da022de1d71073769673cafe5885a9b..3b2cafbbe5db5ed833212f79e6fd61e69d6046c9 100644 --- a/ets2panda/ir/ts/tsTypeParameter.h +++ b/ets2panda/ir/ts/tsTypeParameter.h @@ -65,6 +65,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeParameterDeclaration.cpp b/ets2panda/ir/ts/tsTypeParameterDeclaration.cpp index 128f2abae2068a644352b0db973d26b3e4956116..0a34564701a933c11ca28c22506d4a7249bc6bbf 100644 --- a/ets2panda/ir/ts/tsTypeParameterDeclaration.cpp +++ b/ets2panda/ir/ts/tsTypeParameterDeclaration.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/ts/tsTypeParameter.h" namespace panda::es2panda::ir { @@ -42,6 +43,16 @@ void TSTypeParameterDeclaration::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSTypeParameterDeclaration"}, {"params", params_}}); } +void TSTypeParameterDeclaration::Dump(ir::SrcDumper *dumper) const +{ + for (auto param : params_) { + param->Dump(dumper); + if (param != params_.back()) { + dumper->Add(", "); + } + } +} + void TSTypeParameterDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeParameterDeclaration.h b/ets2panda/ir/ts/tsTypeParameterDeclaration.h index cf2b725a49c0043cc9906d04e191841f48c3b841..d0e81380ab81aab9e68c1d79855d77e8cb6a3ec9 100644 --- a/ets2panda/ir/ts/tsTypeParameterDeclaration.h +++ b/ets2panda/ir/ts/tsTypeParameterDeclaration.h @@ -67,6 +67,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeParameterInstantiation.cpp b/ets2panda/ir/ts/tsTypeParameterInstantiation.cpp index e4174bf081fb6118d623ad5ce439b0dee02a38c5..ef538c9bcf72eee3a1a702979bec167a0f0163f1 100644 --- a/ets2panda/ir/ts/tsTypeParameterInstantiation.cpp +++ b/ets2panda/ir/ts/tsTypeParameterInstantiation.cpp @@ -20,6 +20,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expression.h" #include "ir/typeNode.h" @@ -66,6 +67,20 @@ void TSTypeParameterInstantiation::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSTypeParameterInstantiation"}, {"params", params_}}); } +void TSTypeParameterInstantiation::Dump(ir::SrcDumper *dumper) const +{ + if (!params_.empty()) { + dumper->Add("<"); + for (auto param : params_) { + param->Dump(dumper); + if (param != params_.back()) { + dumper->Add(", "); + } + } + dumper->Add(">"); + } +} + void TSTypeParameterInstantiation::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeParameterInstantiation.h b/ets2panda/ir/ts/tsTypeParameterInstantiation.h index b05622389812449ffedb6cf637f7583100fc1765..be57a1c502e38aa4e83c37d498263212135bfbe5 100644 --- a/ets2panda/ir/ts/tsTypeParameterInstantiation.h +++ b/ets2panda/ir/ts/tsTypeParameterInstantiation.h @@ -48,6 +48,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypePredicate.cpp b/ets2panda/ir/ts/tsTypePredicate.cpp index 16c99b8747da8bd8615dc326242b48f93af2ba9a..944b36c0e646ee76d3c29b1ab2a38ab8453d636c 100644 --- a/ets2panda/ir/ts/tsTypePredicate.cpp +++ b/ets2panda/ir/ts/tsTypePredicate.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/typeNode.h" #include "ir/expression.h" @@ -46,6 +47,10 @@ void TSTypePredicate::Dump(ir::AstDumper *dumper) const {"typeAnnotation", AstDumper::Nullish(type_annotation_)}, {"asserts", asserts_}}); } +void TSTypePredicate::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSTypePredicate"); +} void TSTypePredicate::Compile([[maybe_unused]] compiler::PandaGen *pg) const { diff --git a/ets2panda/ir/ts/tsTypePredicate.h b/ets2panda/ir/ts/tsTypePredicate.h index 9a9ac81a86548b39bee4c76be329bc7425afdc95..7c67230dc4a69b7cadae12f6e73fd7d78c4db4c1 100644 --- a/ets2panda/ir/ts/tsTypePredicate.h +++ b/ets2panda/ir/ts/tsTypePredicate.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeQuery.cpp b/ets2panda/ir/ts/tsTypeQuery.cpp index cb45ace08c1db5708ae58ea18132dad7ba709cb1..c9f24088cb9c938c8a1175b59a11441cbd306989 100644 --- a/ets2panda/ir/ts/tsTypeQuery.cpp +++ b/ets2panda/ir/ts/tsTypeQuery.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "checker/TSchecker.h" namespace panda::es2panda::ir { @@ -37,6 +38,11 @@ void TSTypeQuery::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSTypeQuery"}, {"exprName", expr_name_}}); } +void TSTypeQuery::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSTypeQuery"); +} + void TSTypeQuery::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeQuery.h b/ets2panda/ir/ts/tsTypeQuery.h index 0c6b3a86d255360a8ab8d1148b061f82d0c53edf..83a2ffbbbcbd089579ffcbb333c06de4a3075213 100644 --- a/ets2panda/ir/ts/tsTypeQuery.h +++ b/ets2panda/ir/ts/tsTypeQuery.h @@ -35,6 +35,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsTypeReference.cpp b/ets2panda/ir/ts/tsTypeReference.cpp index ed6d359cefcf88b11ff1ff199c8c0aecb4c191ca..654fbd59e8ec3f5c646ca27a23a475931b5fbae8 100644 --- a/ets2panda/ir/ts/tsTypeReference.cpp +++ b/ets2panda/ir/ts/tsTypeReference.cpp @@ -22,6 +22,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" #include "ir/expressions/identifier.h" #include "ir/ts/tsInterfaceDeclaration.h" #include "ir/ts/tsTypeAliasDeclaration.h" @@ -54,6 +55,11 @@ void TSTypeReference::Dump(ir::AstDumper *dumper) const {{"type", "TSTypeReference"}, {"typeName", type_name_}, {"typeParameters", AstDumper::Optional(type_params_)}}); } +void TSTypeReference::Dump(ir::SrcDumper *dumper) const +{ + BaseName()->Dump(dumper); +} + void TSTypeReference::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsTypeReference.h b/ets2panda/ir/ts/tsTypeReference.h index 3bbed87b89c28b2c4c8e7606f7e2baf1b8b50a29..24f64e8e23685335fed233c567eb22ec8fa86582 100644 --- a/ets2panda/ir/ts/tsTypeReference.h +++ b/ets2panda/ir/ts/tsTypeReference.h @@ -47,6 +47,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsUndefinedKeyword.cpp b/ets2panda/ir/ts/tsUndefinedKeyword.cpp index ba59f6f222104216981d9d0947bfec593be26db7..30bd1818c20dd6a1e337a815ac66cafc4d256d9e 100644 --- a/ets2panda/ir/ts/tsUndefinedKeyword.cpp +++ b/ets2panda/ir/ts/tsUndefinedKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSUndefinedKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSUndefinedKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSUndefinedKeyword"}}); } +void TSUndefinedKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSUndefinedKeyword"); +} + void TSUndefinedKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsUndefinedKeyword.h b/ets2panda/ir/ts/tsUndefinedKeyword.h index cff5e9407892e6ed15cf6586b899af767a134198..14fc4cd18ec6be2a2a183af39a9d076b9d46f467 100644 --- a/ets2panda/ir/ts/tsUndefinedKeyword.h +++ b/ets2panda/ir/ts/tsUndefinedKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsUnionType.cpp b/ets2panda/ir/ts/tsUnionType.cpp index 802d5d65c7695cdd3ada084044b419d576a14186..2d8c04d860e6237f6c55ac14d89d33ec6c28bbdb 100644 --- a/ets2panda/ir/ts/tsUnionType.cpp +++ b/ets2panda/ir/ts/tsUnionType.cpp @@ -19,6 +19,7 @@ #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" #include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSUnionType::TransformChildren(const NodeTransformer &cb) @@ -40,6 +41,11 @@ void TSUnionType::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSUnionType"}, {"types", types_}}); } +void TSUnionType::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSUnionType"); +} + void TSUnionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsUnionType.h b/ets2panda/ir/ts/tsUnionType.h index 925f710106dc8886d8d836e5420b98745af74b10..c32c87512ba18caa25a84a98951cef2fa7ff5197 100644 --- a/ets2panda/ir/ts/tsUnionType.h +++ b/ets2panda/ir/ts/tsUnionType.h @@ -34,6 +34,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsUnknownKeyword.cpp b/ets2panda/ir/ts/tsUnknownKeyword.cpp index d8e35bf46a3b69854a8209cb66f10adb66a48b21..44cae09613230799b9b71a777a420e4e54995011 100644 --- a/ets2panda/ir/ts/tsUnknownKeyword.cpp +++ b/ets2panda/ir/ts/tsUnknownKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSUnknownKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSUnknownKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSUnknownKeyword"}}); } +void TSUnknownKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSUnknownKeyword"); +} + void TSUnknownKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsUnknownKeyword.h b/ets2panda/ir/ts/tsUnknownKeyword.h index 6f2a3783108591222afd50a6b621f2287cc50c89..0100912bd370d264bac85217d1cc31fce3a0048d 100644 --- a/ets2panda/ir/ts/tsUnknownKeyword.h +++ b/ets2panda/ir/ts/tsUnknownKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/ir/ts/tsVoidKeyword.cpp b/ets2panda/ir/ts/tsVoidKeyword.cpp index 47502deb375b1b5088bd99d2837c606d2f93b6d4..5b39b72511311c46d803d97fa1b452ccec5368bc 100644 --- a/ets2panda/ir/ts/tsVoidKeyword.cpp +++ b/ets2panda/ir/ts/tsVoidKeyword.cpp @@ -18,6 +18,8 @@ #include "checker/TSchecker.h" #include "compiler/core/ETSGen.h" #include "compiler/core/pandagen.h" +#include "ir/astDump.h" +#include "ir/srcDump.h" namespace panda::es2panda::ir { void TSVoidKeyword::TransformChildren([[maybe_unused]] const NodeTransformer &cb) {} @@ -28,6 +30,11 @@ void TSVoidKeyword::Dump(ir::AstDumper *dumper) const dumper->Add({{"type", "TSVoidKeyword"}}); } +void TSVoidKeyword::Dump(ir::SrcDumper *dumper) const +{ + dumper->Add("TSVoidKeyword"); +} + void TSVoidKeyword::Compile(compiler::PandaGen *pg) const { pg->GetAstCompiler()->Compile(this); diff --git a/ets2panda/ir/ts/tsVoidKeyword.h b/ets2panda/ir/ts/tsVoidKeyword.h index 7525b4683b6889a960c0a51f331e68c86584265f..0ceee4d69a3bba950792f40457f0ad81232feb91 100644 --- a/ets2panda/ir/ts/tsVoidKeyword.h +++ b/ets2panda/ir/ts/tsVoidKeyword.h @@ -26,6 +26,7 @@ public: void TransformChildren(const NodeTransformer &cb) override; void Iterate(const NodeTraverser &cb) const override; void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; void Compile(compiler::PandaGen *pg) const override; void Compile(compiler::ETSGen *etsg) const override; checker::Type *Check(checker::TSChecker *checker) override; diff --git a/ets2panda/test/unit/ast_dumper_test.cpp b/ets2panda/test/unit/ast_dumper_test.cpp index 6d38b78fe12935540b47fd79bef2131b805105ce..ed60d54272091c36316eb5057639cef7320a10a3 100644 --- a/ets2panda/test/unit/ast_dumper_test.cpp +++ b/ets2panda/test/unit/ast_dumper_test.cpp @@ -119,3 +119,29 @@ TEST_F(ASTDumperTest, DumpJsonUTF16Char) ASSERT_FALSE(dump_str.empty()); } + +TEST_F(ASTDumperTest, DumpEtsSrcSimple) +{ + static constexpr std::string_view FILE_NAME = "dummy.ets"; + static constexpr std::string_view SRC = + "\ + function main(args: String[]): int {\ + let a: int = 2;\ + let b: int = 3;\ + return a + b;\ + }"; + + int argc = 1; + const char *argv = + "--extension=ets " + "--dump-ets-src-before-phases=\"plugins-after-parse:lambda-lowering:checker:plugins-after-check:generate-ts-" + "declarations:op-assignment:tuple-lowering:union-property-access:plugins-after-lowering\""; + + auto program = std::unique_ptr {GetProgram(argc, &argv, FILE_NAME, SRC)}; + + ASSERT_NE(program, nullptr); + + auto dump_str = program->JsonDump(); + + ASSERT_FALSE(dump_str.empty()); +} diff --git a/ets2panda/util/options.cpp b/ets2panda/util/options.cpp index f05099ad672a2ebebad10aaccc9559b9db65ed75..2412f39cb037729c6d495c9d1bb9059d0cee829e 100644 --- a/ets2panda/util/options.cpp +++ b/ets2panda/util/options.cpp @@ -181,8 +181,12 @@ bool Options::Parse(int argc, const char **argv) panda::PandArg skip_phases("skip-phases", "", "Phases to skip"); panda::PandArg dump_before_phases("dump-before-phases", "", "Generate program dump before running phases in the list"); + panda::PandArg dump_ets_src_before_phases( + "dump-ets-src-before-phases", "", "Generate program dump as ets source code before running phases in the list"); panda::PandArg dump_after_phases("dump-after-phases", "", "Generate program dump after running phases in the list"); + panda::PandArg dump_ets_src_after_phases( + "dump-ets-src-after-phases", "", "Generate program dump as ets source code after running phases in the list"); panda::PandArg arkts_config("arktsconfig", DEFAULT_ARKTSCONFIG, "Path to arkts configuration file"); // tail arguments @@ -212,7 +216,9 @@ bool Options::Parse(int argc, const char **argv) argparser_->Add(&plugins); argparser_->Add(&skip_phases); argparser_->Add(&dump_before_phases); + argparser_->Add(&dump_ets_src_before_phases); argparser_->Add(&dump_after_phases); + argparser_->Add(&dump_ets_src_after_phases); argparser_->Add(&arkts_config); argparser_->Add(&op_ts_decl_out); @@ -388,6 +394,12 @@ bool Options::Parse(int argc, const char **argv) } } + if ((dump_ets_src_before_phases.GetValue().size() + dump_ets_src_after_phases.GetValue().size() > 0) && + extension_ != es2panda::ScriptExtension::ETS) { + error_msg_ = "--dump-ets-src-* option is valid only with ETS extension"; + return false; + } + compiler_options_.ts_decl_out = op_ts_decl_out.GetValue(); compiler_options_.dump_asm = op_dump_assembly.GetValue(); compiler_options_.dump_ast = op_dump_ast.GetValue(); @@ -402,7 +414,9 @@ bool Options::Parse(int argc, const char **argv) compiler_options_.plugins = SplitToStringVector(plugins.GetValue()); compiler_options_.skip_phases = SplitToStringSet(skip_phases.GetValue()); compiler_options_.dump_before_phases = SplitToStringSet(dump_before_phases.GetValue()); + compiler_options_.dump_ets_src_before_phases = SplitToStringSet(dump_ets_src_before_phases.GetValue()); compiler_options_.dump_after_phases = SplitToStringSet(dump_after_phases.GetValue()); + compiler_options_.dump_ets_src_after_phases = SplitToStringSet(dump_ets_src_after_phases.GetValue()); return true; }