From d1e8f727ad65654ce3d2ce37b633e2d5b9e4c4e1 Mon Sep 17 00:00:00 2001 From: zengzengran Date: Tue, 10 Jun 2025 15:18:36 +0800 Subject: [PATCH 1/3] Implement overload declaration Issue: https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICFDGM Description: 1. Create ASTNode ir::OverloadDeclaration and perform scope initialization. 2. Check ir::OverloadDeclaration. 3. Implement first match (currently only for OverloadDeclaration call, current overload cannot be removed for the time). If the match fails, clear the TypeError and ASTNode check information. Tested-by: ninja tests (passed) ets_testrunner (passed) Signed-off-by: zengzengran Signed-off-by: tengtengh --- ets2panda/BUILD.gn | 22 +- ets2panda/CMakeLists.txt | 2 + .../ast_verifier/invariants/nodeHasType.cpp | 3 +- ets2panda/checker/ETSAnalyzer.cpp | 92 +++++ ets2panda/checker/ETSchecker.h | 35 ++ ets2panda/checker/SemanticAnalyzer.h | 1 + ets2panda/checker/TSAnalyzerUnreachable.cpp | 5 + ets2panda/checker/checker.h | 36 ++ ets2panda/checker/ets/function.cpp | 333 +++++++++++++++++- ets2panda/checker/ets/helpers.cpp | 10 + ets2panda/checker/ets/object.cpp | 124 +++++-- ets2panda/checker/ets/typeCheckingHelpers.cpp | 200 +++++++++++ ets2panda/checker/ets/validateHelpers.cpp | 4 + ets2panda/checker/types/ets/etsObjectType.cpp | 206 +++++++---- ets2panda/checker/types/ets/etsObjectType.h | 15 +- .../compiler/core/ETSCompilerUnrechable.cpp | 5 + ets2panda/compiler/core/ETSemitter.cpp | 43 +++ ets2panda/compiler/core/ETSemitter.h | 1 + .../compiler/core/JSCompilerUnreachable.cpp | 5 + ...defaultParametersInConstructorLowering.cpp | 2 +- .../ets/interfaceObjectLiteralLowering.cpp | 7 + .../compiler/lowering/ets/lambdaLowering.cpp | 15 +- .../lowering/ets/overloadMappingLowering.cpp | 83 +++++ .../lowering/ets/overloadMappingLowering.h | 31 ++ .../lowering/ets/restTupleLowering.cpp | 2 +- .../topLevelStmts/globalDeclTransformer.cpp | 5 + .../ets/topLevelStmts/globalDeclTransformer.h | 1 + .../ets/topLevelStmts/importExportDecls.cpp | 5 + .../ets/topLevelStmts/importExportDecls.h | 1 + ets2panda/compiler/lowering/phase.cpp | 2 + .../lowering/scopesInit/scopesInitPhase.cpp | 117 +++++- .../lowering/scopesInit/scopesInitPhase.h | 3 + ets2panda/compiler/scripts/signatures.yaml | 7 + ets2panda/ir/astNode.cpp | 13 +- ets2panda/ir/astNode.h | 2 + ets2panda/ir/astNodeFlags.h | 14 +- ets2panda/ir/astNodeMapping.h | 1 + ets2panda/ir/base/methodDefinition.cpp | 5 + ets2panda/ir/base/overloadDeclaration.cpp | 134 +++++++ ets2panda/ir/base/overloadDeclaration.h | 140 ++++++++ ets2panda/ir/base/scriptFunction.h | 5 + .../ir/ets/etsNewArrayInstanceExpression.cpp | 9 + .../ir/ets/etsNewArrayInstanceExpression.h | 1 + .../etsNewMultiDimArrayInstanceExpression.cpp | 9 + .../etsNewMultiDimArrayInstanceExpression.h | 1 + ets2panda/ir/ets/etsUnionType.cpp | 2 + ets2panda/ir/expressions/arrayExpression.cpp | 10 + ets2panda/ir/expressions/arrayExpression.h | 1 + ets2panda/ir/expressions/memberExpression.cpp | 5 + ets2panda/ir/expressions/objectExpression.cpp | 7 + ets2panda/ir/expressions/objectExpression.h | 2 + ets2panda/ir/opaqueTypeNode.cpp | 3 + ets2panda/ir/opaqueTypeNode.h | 1 + ets2panda/lexer/scripts/keywords.yaml | 4 + ets2panda/parser/ETSparser.cpp | 91 ++++- ets2panda/parser/ETSparser.h | 6 + ets2panda/parser/ETSparserClasses.cpp | 81 ++++- ets2panda/parser/ETSparserStatements.cpp | 4 + ets2panda/parser/parserImpl.cpp | 2 +- ets2panda/public/CMakeLists.txt | 2 + .../public/headers_parser/supported_types.py | 1 + .../ets/first_match/abstract_method.ets | 23 ++ .../ets/first_match/access_modifiers.ets | 50 +++ .../ets/first_match/access_modifiers_2.ets | 36 ++ .../compiler/ets/first_match/arrayliteral.ets | 39 ++ .../compiler/ets/first_match/constructor.ets | 52 +++ .../ets/first_match/invalid_declaration.ets | 33 ++ .../ets/first_match/invalid_declaration_2.ets | 31 ++ .../ets/first_match/invalid_declaration_3.ets | 25 ++ .../ets/first_match/invalid_declaration_4.ets | 23 ++ .../ets/first_match/invalid_identifier.ets | 52 +++ .../ets/first_match/invalid_paramter.ets | 40 +++ .../ets/first_match/modifier_async.ets | 29 ++ .../ets/first_match/modifier_static.ets | 29 ++ .../ast/compiler/ets/first_match/override.ets | 39 ++ .../class_overloaded_name_must_ident.ets | 24 ++ ...constructor_overloaded_name_must_ident.ets | 24 ++ ...on_overloaded_name_must_qualified_name.ets | 26 ++ .../interface_overloaded_name_must_ident.ets | 23 ++ .../overload/overload_duplicate_function.ets | 33 ++ .../overload_duplicate_function_2.ets | 37 ++ .../overload/overload_duplicate_method.ets | 34 ++ .../overload_duplicate_overload_name_1.ets | 26 ++ .../overload/overload_from_super_class.ets | 26 ++ .../overload_overloaded_method_exported.ets | 20 ++ ...verload_overloaded_name_at_most_once_1.ets | 31 ++ ...erload_overloaded_name_used_as_value_1.ets | 27 ++ ...erload_overloaded_name_used_as_value_2.ets | 27 ++ .../ets/overload/overload_union_call.ets | 38 ++ .../ets/overload/overload_union_call_2.ets | 35 ++ .../parser/ets/overload_class_method_test.ets | 33 ++ .../ast/parser/ets/overload_constructor.ets | 34 ++ ...verload_global_function_our_style_test.ets | 32 ++ .../ets/overload_interface_method_test.ets | 25 ++ .../overload_modifier_overloaddefinition.ets | 64 ++++ .../ets/first_match/access_modifiers.ets | 50 +++ .../test/runtime/ets/first_match/array.ets | 45 +++ .../ets/first_match/array_and_tuple.ets | 42 +++ .../first_match/ctor_need_fix_bytecode.ets | 59 ++++ .../test/runtime/ets/first_match/enum.ets | 90 +++++ .../test/runtime/ets/first_match/enum2.ets | 35 ++ .../function_need_fix_variable.ets | 39 ++ .../test/runtime/ets/first_match/generics.ets | 50 +++ .../runtime/ets/first_match/generics_2.ets | 44 +++ .../runtime/ets/first_match/lambda_infer.ets | 44 +++ .../runtime/ets/first_match/lambda_order.ets | 51 +++ .../ets/first_match/lambda_type_alias.ets | 46 +++ .../runtime/ets/first_match/namespace.ets | 35 ++ .../runtime/ets/first_match/namespace2.ets | 46 +++ .../runtime/ets/first_match/namespace3.ets | 44 +++ .../first_match/objectliteral_optional.ets | 69 ++++ .../ets/first_match/objectliteral_order.ets | 48 +++ .../ets/first_match/objectliteral_same.ets | 53 +++ .../ets/first_match/optinal_parameter.ets | 47 +++ .../ets/first_match/override_class.ets | 48 +++ .../ets/first_match/override_interface.ets | 55 +++ .../runtime/ets/first_match/primitive.ets | 48 +++ .../ets/first_match/rest_parameter.ets | 52 +++ .../ets/first_match/static_and_nonstatic.ets | 42 +++ .../runtime/ets/first_match/stringliteral.ets | 35 ++ .../ets/first_match/trailing_lambda.ets | 53 +++ .../test/runtime/ets/first_match/union.ets | 43 +++ .../ets/overload_declaration/15445.ets | 36 ++ .../ets/overload_declaration/15502.ets | 36 ++ .../ets/overload_declaration/Enum2.ets | 61 ++++ .../FirstMatchSignature01.ets | 28 ++ .../FirstMatchSignature02.ets | 28 ++ .../FirstMatchSignature03.ets | 28 ++ .../FirstMatchSignature04.ets | 28 ++ .../FirstMatchSignature05.ets | 32 ++ .../FirstMatchSignature06.ets | 32 ++ .../FirstMatchSignature07.ets | 33 ++ .../overload_declaration/FixFunctionCall.ets | 27 ++ .../overload_declaration/FunctionOverload.ets | 44 +++ .../InterfacePrivateMethod2.ets | 43 +++ .../ets/overload_declaration/RestTuple4.ets | 47 +++ .../ets/overload_declaration/RestTuple8.ets | 47 +++ .../ets/overload_declaration/SmartCast_03.ets | 74 ++++ .../async-func-overload-and-type-infer.ets | 41 +++ .../async_method_with_same_name02.ets | 31 ++ .../conditionalExpressionLUB.ets | 94 +++++ .../constructor-issue.ets | 61 ++++ ...constructor_overload_sig_with_ref_type.ets | 41 +++ .../default_parameter1.ets | 28 ++ .../first_match_method_with_rest_param_2.ets | 27 ++ .../first_match_method_with_rest_param_3.ets | 21 ++ .../ets/overload_declaration/generic-set.ets | 96 +++++ .../keyword_get_set_as_identfier2.ets | 31 ++ .../ets/overload_declaration/notNull.ets | 169 +++++++++ .../overload_declaration/objectLiteral.ets | 75 ++++ .../overload-primitive-and-object.ets | 41 +++ .../overload-resolution-rest-1.ets | 37 ++ .../overload-resolution-rest-2.ets | 28 ++ .../ets/overload_declaration/overload_1.ets | 25 ++ .../overload_declaration/overload_call_1.ets | 39 ++ .../signature_match_lambda.ets | 43 +++ .../visible_signatures.ets | 59 ++++ ets2panda/util/diagnostic/semantic.yaml | 40 +++ ets2panda/util/diagnostic/syntax.yaml | 12 + ets2panda/util/diagnosticEngine.cpp | 23 ++ ets2panda/util/diagnosticEngine.h | 8 + ets2panda/varbinder/ETSBinder.cpp | 13 +- ets2panda/varbinder/ETSBinder.h | 1 + ets2panda/varbinder/variableFlags.h | 1 + 164 files changed, 6000 insertions(+), 121 deletions(-) create mode 100644 ets2panda/compiler/lowering/ets/overloadMappingLowering.cpp create mode 100644 ets2panda/compiler/lowering/ets/overloadMappingLowering.h create mode 100644 ets2panda/ir/base/overloadDeclaration.cpp create mode 100644 ets2panda/ir/base/overloadDeclaration.h create mode 100644 ets2panda/test/ast/compiler/ets/first_match/abstract_method.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/access_modifiers.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/access_modifiers_2.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/arrayliteral.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/constructor.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/invalid_declaration.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_2.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_3.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_4.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/invalid_identifier.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/invalid_paramter.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/modifier_async.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/modifier_static.ets create mode 100644 ets2panda/test/ast/compiler/ets/first_match/override.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/class_overloaded_name_must_ident.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/constructor_overloaded_name_must_ident.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/function_overloaded_name_must_qualified_name.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/interface_overloaded_name_must_ident.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function_2.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_duplicate_method.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_duplicate_overload_name_1.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_from_super_class.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_overloaded_method_exported.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_at_most_once_1.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_1.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_2.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_union_call.ets create mode 100644 ets2panda/test/ast/compiler/ets/overload/overload_union_call_2.ets create mode 100644 ets2panda/test/ast/parser/ets/overload_class_method_test.ets create mode 100644 ets2panda/test/ast/parser/ets/overload_constructor.ets create mode 100644 ets2panda/test/ast/parser/ets/overload_global_function_our_style_test.ets create mode 100644 ets2panda/test/ast/parser/ets/overload_interface_method_test.ets create mode 100644 ets2panda/test/ast/parser/ets/overload_modifier_overloaddefinition.ets create mode 100644 ets2panda/test/runtime/ets/first_match/access_modifiers.ets create mode 100644 ets2panda/test/runtime/ets/first_match/array.ets create mode 100644 ets2panda/test/runtime/ets/first_match/array_and_tuple.ets create mode 100644 ets2panda/test/runtime/ets/first_match/ctor_need_fix_bytecode.ets create mode 100644 ets2panda/test/runtime/ets/first_match/enum.ets create mode 100644 ets2panda/test/runtime/ets/first_match/enum2.ets create mode 100644 ets2panda/test/runtime/ets/first_match/function_need_fix_variable.ets create mode 100644 ets2panda/test/runtime/ets/first_match/generics.ets create mode 100644 ets2panda/test/runtime/ets/first_match/generics_2.ets create mode 100644 ets2panda/test/runtime/ets/first_match/lambda_infer.ets create mode 100644 ets2panda/test/runtime/ets/first_match/lambda_order.ets create mode 100644 ets2panda/test/runtime/ets/first_match/lambda_type_alias.ets create mode 100644 ets2panda/test/runtime/ets/first_match/namespace.ets create mode 100644 ets2panda/test/runtime/ets/first_match/namespace2.ets create mode 100644 ets2panda/test/runtime/ets/first_match/namespace3.ets create mode 100644 ets2panda/test/runtime/ets/first_match/objectliteral_optional.ets create mode 100644 ets2panda/test/runtime/ets/first_match/objectliteral_order.ets create mode 100644 ets2panda/test/runtime/ets/first_match/objectliteral_same.ets create mode 100644 ets2panda/test/runtime/ets/first_match/optinal_parameter.ets create mode 100644 ets2panda/test/runtime/ets/first_match/override_class.ets create mode 100644 ets2panda/test/runtime/ets/first_match/override_interface.ets create mode 100644 ets2panda/test/runtime/ets/first_match/primitive.ets create mode 100644 ets2panda/test/runtime/ets/first_match/rest_parameter.ets create mode 100644 ets2panda/test/runtime/ets/first_match/static_and_nonstatic.ets create mode 100644 ets2panda/test/runtime/ets/first_match/stringliteral.ets create mode 100644 ets2panda/test/runtime/ets/first_match/trailing_lambda.ets create mode 100644 ets2panda/test/runtime/ets/first_match/union.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/15445.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/15502.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/Enum2.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature01.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature02.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature03.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature04.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature05.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature06.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature07.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FixFunctionCall.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/FunctionOverload.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/InterfacePrivateMethod2.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/RestTuple4.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/RestTuple8.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/SmartCast_03.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/async-func-overload-and-type-infer.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/async_method_with_same_name02.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/conditionalExpressionLUB.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/constructor-issue.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/constructor_overload_sig_with_ref_type.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/default_parameter1.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_2.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_3.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/generic-set.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/keyword_get_set_as_identfier2.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/notNull.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/objectLiteral.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/overload-primitive-and-object.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-1.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-2.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/overload_1.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/overload_call_1.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/signature_match_lambda.ets create mode 100644 ets2panda/test/runtime/ets/overload_declaration/visible_signatures.ets diff --git a/ets2panda/BUILD.gn b/ets2panda/BUILD.gn index eb093c2ad4..e9c4dee5ec 100644 --- a/ets2panda/BUILD.gn +++ b/ets2panda/BUILD.gn @@ -103,6 +103,7 @@ libes2panda_sources = [ "checker/types/ets/byteType.cpp", "checker/types/ets/charType.cpp", "checker/types/ets/doubleType.cpp", + "checker/types/ets/etsAnyType.cpp", "checker/types/ets/etsArrayType.cpp", "checker/types/ets/etsAsyncFuncReturnType.cpp", "checker/types/ets/etsBigIntType.cpp", @@ -127,7 +128,6 @@ libes2panda_sources = [ "checker/types/ets/intType.cpp", "checker/types/ets/longType.cpp", "checker/types/ets/shortType.cpp", - "checker/types/ets/etsAnyType.cpp", "checker/types/ets/wildcardType.cpp", "checker/types/globalTypesHolder.cpp", "checker/types/gradualType.cpp", @@ -206,6 +206,8 @@ libes2panda_sources = [ "compiler/function/generatorFunctionBuilder.cpp", "compiler/lowering/checkerPhase.cpp", "compiler/lowering/ets/ambientLowering.cpp", + "compiler/lowering/ets/annotationCopyLowering.cpp", + "compiler/lowering/ets/annotationCopyPostLowering.cpp", "compiler/lowering/ets/arrayLiteralLowering.cpp", "compiler/lowering/ets/asyncMethodLowering.cpp", "compiler/lowering/ets/bigintLowering.cpp", @@ -218,6 +220,7 @@ libes2panda_sources = [ "compiler/lowering/ets/declGenPhase.cpp", "compiler/lowering/ets/defaultParametersInConstructorLowering.cpp", "compiler/lowering/ets/defaultParametersLowering.cpp", + "compiler/lowering/ets/dynamicImport.cpp", "compiler/lowering/ets/enumLowering.cpp", "compiler/lowering/ets/enumPostCheckLowering.cpp", "compiler/lowering/ets/enumPropertiesInAnnotationsLowering.cpp", @@ -230,9 +233,8 @@ libes2panda_sources = [ "compiler/lowering/ets/insertOptionalParametersAnnotation.cpp", "compiler/lowering/ets/interfaceObjectLiteralLowering.cpp", "compiler/lowering/ets/interfacePropertyDeclarations.cpp", - "compiler/lowering/ets/lateInitialization.cpp", "compiler/lowering/ets/lambdaLowering.cpp", - "compiler/lowering/ets/dynamicImport.cpp", + "compiler/lowering/ets/lateInitialization.cpp", "compiler/lowering/ets/localClassLowering.cpp", "compiler/lowering/ets/objectIndexAccess.cpp", "compiler/lowering/ets/objectIterator.cpp", @@ -240,6 +242,7 @@ libes2panda_sources = [ "compiler/lowering/ets/opAssignment.cpp", "compiler/lowering/ets/optionalArgumentsLowering.cpp", "compiler/lowering/ets/optionalLowering.cpp", + "compiler/lowering/ets/overloadMappingLowering.cpp", "compiler/lowering/ets/packageImplicitImport.cpp", "compiler/lowering/ets/partialExportClassGen.cpp", "compiler/lowering/ets/primitiveConversionPhase.cpp", @@ -260,8 +263,6 @@ libes2panda_sources = [ "compiler/lowering/ets/typeFromLowering.cpp", "compiler/lowering/ets/unboxLowering.cpp", "compiler/lowering/ets/unionLowering.cpp", - "compiler/lowering/ets/annotationCopyLowering.cpp", - "compiler/lowering/ets/annotationCopyPostLowering.cpp", "compiler/lowering/phase.cpp", "compiler/lowering/plugin_phase.cpp", "compiler/lowering/resolveIdentifiers.cpp", @@ -294,6 +295,7 @@ libes2panda_sources = [ "ir/base/decorator.cpp", "ir/base/metaProperty.cpp", "ir/base/methodDefinition.cpp", + "ir/base/overloadDeclaration.cpp", "ir/base/property.cpp", "ir/base/scriptFunction.cpp", "ir/base/scriptFunctionSignature.cpp", @@ -727,6 +729,7 @@ HEADERS_TO_BE_PARSED = [ "ir/ts/tsImportEqualsDeclaration.h", "ir/validationInfo.h", "ir/base/methodDefinition.h", + "ir/base/overloadDeclaration.h", "ir/ts/tsIntersectionType.h", "checker/types/ts/nullType.h", "checker/types/ts/unknownType.h", @@ -783,7 +786,7 @@ HEADERS_TO_BE_PARSED = [ "util/importPathManager.h", "util/options.h", "util/path.h", - "util/arktsconfig.h" + "util/arktsconfig.h", ] ES2PANDA_API_GENERATED = [ @@ -976,6 +979,7 @@ ES2PANDA_API_GENERATED = [ "$LIBGEN_DIR/gen/headers/ir/expressions/directEvalExpression.yaml", "$LIBGEN_DIR/gen/headers/ir/ts/tsTypeParameterDeclaration.yaml", "$LIBGEN_DIR/gen/headers/ir/base/methodDefinition.yaml", + "$LIBGEN_DIR/gen/headers/ir/base/overloadDeclaration.yaml", "$LIBGEN_DIR/gen/headers/ir/ts/tsNullKeyword.yaml", "$LIBGEN_DIR/gen/headers/ir/ts/tsInterfaceHeritage.yaml", "$LIBGEN_DIR/gen/headers/checker/types/ts/enumLiteralType.yaml", @@ -1070,9 +1074,9 @@ action("libes2panda_public_parse_headers") { script = "./public/headers_parser/main.py" deps = [ + ":check_build_system_consistency", ":es2panda_options_gen_options_h", ":gen_es2panda_lexer_tokenType_h", - ":check_build_system_consistency", ] generated_headers = [ @@ -1112,8 +1116,8 @@ ark_gen("gen") { # libes2panda does not include bytecode optimizer, because it is used in # libarkruntime, and conflict with JIT setup ensues libes2panda_public_sources = [ - "declgen_ets2ts/isolatedDeclgenChecker.cpp", "declgen_ets2ts/declgenEts2Ts.cpp", + "declgen_ets2ts/isolatedDeclgenChecker.cpp", "public/${LIB_NAME}.cpp", "util/generateBin.cpp", "util/options.cpp", @@ -1165,10 +1169,10 @@ ohos_source_set("libes2panda_frontend_static") { ":es2panda_options_gen_options_h", ":gen_${LIB_NAME}_decl_inc", ":gen_${LIB_NAME}_enums_inc", + ":gen_${LIB_NAME}_idl", ":gen_${LIB_NAME}_impl_inc", ":gen_${LIB_NAME}_include_inc", ":gen_${LIB_NAME}_list_inc", - ":gen_${LIB_NAME}_idl", ":gen_es2panda_compiler_signatures_h", ":gen_es2panda_lexer_keywords_h", ":gen_es2panda_lexer_tokenType_h", diff --git a/ets2panda/CMakeLists.txt b/ets2panda/CMakeLists.txt index c53de4f112..1f0676370b 100644 --- a/ets2panda/CMakeLists.txt +++ b/ets2panda/CMakeLists.txt @@ -308,6 +308,7 @@ set(ES2PANDA_LIB_SRC compiler/lowering/ets/unionLowering.cpp compiler/lowering/ets/optionalArgumentsLowering.cpp compiler/lowering/ets/optionalLowering.cpp + compiler/lowering/ets/overloadMappingLowering.cpp compiler/lowering/ets/expandBrackets.cpp compiler/lowering/ets/packageImplicitImport.cpp compiler/lowering/ets/partialExportClassGen.cpp @@ -342,6 +343,7 @@ set(ES2PANDA_LIB_SRC ir/base/decorator.cpp ir/base/metaProperty.cpp ir/base/methodDefinition.cpp + ir/base/overloadDeclaration.cpp ir/base/property.cpp ir/base/scriptFunction.cpp ir/base/scriptFunctionSignature.cpp diff --git a/ets2panda/ast_verifier/invariants/nodeHasType.cpp b/ets2panda/ast_verifier/invariants/nodeHasType.cpp index 4cfa95f5ca..e9f4d335a7 100644 --- a/ets2panda/ast_verifier/invariants/nodeHasType.cpp +++ b/ets2panda/ast_verifier/invariants/nodeHasType.cpp @@ -38,7 +38,8 @@ public: { return nulltypeNode_->IsIdentifier() || MatchFunctionExpression() || nulltypeNode_->IsTSClassImplements() || nulltypeNode_->IsSpreadElement() || nulltypeNode_->IsTSThisType() || nulltypeNode_->IsETSNullType() || - nulltypeNode_->IsStringLiteral() || AnyChildStringLiteral(); + nulltypeNode_->IsStringLiteral() || AnyChildStringLiteral() || nulltypeNode_->IsOverloadDeclaration() || + nulltypeNode_->IsProperty(); } auto ShouldSkipSubtree() const diff --git a/ets2panda/checker/ETSAnalyzer.cpp b/ets2panda/checker/ETSAnalyzer.cpp index aa6eb3ff15..3d21c91b3b 100644 --- a/ets2panda/checker/ETSAnalyzer.cpp +++ b/ets2panda/checker/ETSAnalyzer.cpp @@ -23,6 +23,7 @@ #include "evaluate/scopedDebugInfoPlugin.h" #include "types/signature.h" #include "compiler/lowering/ets/setJumpTarget.h" +#include "compiler/lowering/util.h" #include "checker/types/ets/etsAsyncFuncReturnType.h" #include "types/ts/nullType.h" #include "types/type.h" @@ -309,6 +310,77 @@ void ETSAnalyzer::CheckMethodModifiers(ir::MethodDefinition *node) const } } +static void CheckDuplicationInOverloadDeclaration(ETSChecker *const checker, ir::OverloadDeclaration *const node) +{ + auto overloadedNameSet = ArenaSet(checker->ProgramAllocator()->Adapter()); + for (ir::Expression *const overloadedName : node->OverloadedList()) { + bool isQualifiedName = true; + std::function getFullOverloadedName = + [&isQualifiedName, &getFullOverloadedName](ir::Expression *const expr) -> std::string { + if (!isQualifiedName) { + return ""; + } + if (expr->IsIdentifier()) { + return expr->AsIdentifier()->Name().Mutf8(); + } + if (expr->IsMemberExpression()) { + return getFullOverloadedName(expr->AsMemberExpression()->Object()) + "." + + getFullOverloadedName(expr->AsMemberExpression()->Property()); + } + isQualifiedName = false; + return ""; + }; + std::string fullOverloadedName = getFullOverloadedName(overloadedName); + if (!isQualifiedName) { + continue; + } + if (overloadedNameSet.find(fullOverloadedName) != overloadedNameSet.end()) { + checker->LogError(diagnostic::DUPLICATE_OVERLOADED_NAME, overloadedName->Start()); + continue; + } + overloadedNameSet.insert(fullOverloadedName); + } +} + +checker::Type *ETSAnalyzer::Check(ir::OverloadDeclaration *node) const +{ + ETSChecker *checker = GetETSChecker(); + ES2PANDA_ASSERT(node != nullptr); + ES2PANDA_ASSERT(node->Key()); + + CheckDuplicationInOverloadDeclaration(checker, node); + + if (!node->Key()->IsIdentifier()) { + checker->LogError(diagnostic::OVERLOAD_NAME_MUST_BE_IDENTIFIER, {}, node->Key()->Start()); + } + + if (node->IsConstructorOverloadDeclaration()) { + ES2PANDA_ASSERT(node->Parent()->IsClassDefinition()); + checker->CheckConstructorOverloadDeclaration(checker, node); + return nullptr; + } + + if (node->IsFunctionOverloadDeclaration()) { + ES2PANDA_ASSERT(node->Parent()->IsClassDefinition() && compiler::HasGlobalClassParent(node)); + checker->CheckFunctionOverloadDeclaration(checker, node); + return nullptr; + } + + if (node->IsClassMethodOverloadDeclaration()) { + ES2PANDA_ASSERT(node->Parent()->IsClassDefinition()); + checker->CheckClassMethodOverloadDeclaration(checker, node); + return nullptr; + } + + if (node->IsInterfaceMethodOverloadDeclaration()) { + ES2PANDA_ASSERT(node->Parent()->Parent()->IsTSInterfaceDeclaration()); + checker->CheckInterfaceMethodOverloadDeclaration(checker, node); + return nullptr; + } + + return nullptr; +} + checker::Type *ETSAnalyzer::Check([[maybe_unused]] ir::Property *expr) const { ETSChecker *checker = GetETSChecker(); @@ -1335,6 +1407,18 @@ static bool LambdaIsField(ir::CallExpression *expr) return me->PropVar() != nullptr; } +static bool OverloadDeclaration(ir::Expression *expr) +{ + while (expr->IsMemberExpression()) { + expr = expr->AsMemberExpression()->Property(); + } + + if (expr->IsIdentifier() && expr->AsIdentifier()->Variable() != nullptr) { + return expr->AsIdentifier()->Variable()->HasFlag(varbinder::VariableFlags::OVERLOAD); + } + return false; +} + checker::Signature *ETSAnalyzer::ResolveSignature(ETSChecker *checker, ir::CallExpression *expr, checker::Type *calleeType) const { @@ -1348,6 +1432,10 @@ checker::Signature *ETSAnalyzer::ResolveSignature(ETSChecker *checker, ir::CallE return checker->ResolveCallExpressionAndTrailingLambda(checker->GetOverloadSigContainer(), expr, expr->Start()); } + if (calleeType->IsETSFunctionType() && OverloadDeclaration(expr->Callee())) { + return checker->FirstMatchSignatures(expr, calleeType); + } + if (calleeType->IsETSExtensionFuncHelperType()) { auto *signature = ResolveCallForETSExtensionFuncHelperType(calleeType->AsETSExtensionFuncHelperType(), checker, expr); @@ -1400,6 +1488,7 @@ Type *ETSAnalyzer::GetReturnType(ir::CallExpression *expr, Type *calleeType) con } Signature *const signature = ResolveSignature(checker, expr, calleeType); + if (signature == nullptr) { return checker->GlobalTypeError(); } @@ -1682,6 +1771,9 @@ static Type *TransformTypeForMethodReference(ETSChecker *checker, ir::Expression if (expr->Parent()->IsCallExpression() && expr->Parent()->AsCallExpression()->Callee() == expr) { return type; // type is actually used as method } + if (expr->Parent()->IsOverloadDeclaration()) { + return type; // Don't trans overloaded name to arrow type. + } auto *const functionType = type->AsETSFunctionType(); auto &signatures = functionType->CallSignatures(); diff --git a/ets2panda/checker/ETSchecker.h b/ets2panda/checker/ETSchecker.h index a66869952a..ed6580fb88 100644 --- a/ets2panda/checker/ETSchecker.h +++ b/ets2panda/checker/ETSchecker.h @@ -273,6 +273,8 @@ public: void CheckCyclicConstructorCall(Signature *signature); std::vector ResolveMemberReference(const ir::MemberExpression *memberExpr, const ETSObjectType *target); + varbinder::LocalVariable *ResolveOverloadReference(const ir::Identifier *ident, ETSObjectType *objType, + PropertySearchFlags searchFlags); void WarnForEndlessLoopInGetterSetter(const ir::MemberExpression *const memberExpr); varbinder::Variable *GetExtensionFuncVarInGlobalFunction(const ir::MemberExpression *const memberExpr); varbinder::Variable *GetExtensionFuncVarInGlobalField(const ir::MemberExpression *const memberExpr); @@ -477,6 +479,31 @@ public: TypeRelationFlag flags, bool reportError, bool unique); void ThrowSignatureMismatch(ArenaVector &signatures, const ArenaVector &arguments, const lexer::SourcePosition &pos, std::string_view signatureKind); + Signature *FirstMatchSignatures(ir::CallExpression *expr, checker::Type *calleeType); + Signature *MatchOrderSignatures(ArenaVector &signatures, + const ir::TSTypeParameterInstantiation *typeArguments, + const ArenaVector &arguments, const lexer::SourcePosition &pos, + TypeRelationFlag resolveFlags); + void CleanArgumentsInformation(const ArenaVector &arguments); + Signature *ValidateOrderSignature( + std::tuple info, + const ArenaVector &arguments, const lexer::SourcePosition &pos, + const std::vector &argTypeInferenceRequired, const bool unique); + bool ValidateOrderSignatureRequiredParams(Signature *substitutedSig, const ArenaVector &arguments, + TypeRelationFlag flags, + const std::vector &argTypeInferenceRequired); + bool ValidateOrderSignatureInvocationContext(Signature *substitutedSig, ir::Expression *argument, std::size_t index, + TypeRelationFlag flags); + void ThrowOverloadMismatch(util::StringView callName, const ArenaVector &arguments, + const lexer::SourcePosition &pos, std::string_view signatureKind); + Signature *ResolveTrailingLambda(ArenaVector &signatures, ir::CallExpression *callExpr, + const lexer::SourcePosition &pos, + TypeRelationFlag reportFlag = TypeRelationFlag::NONE); + Signature *ResolvePotentialTrailingLambda(ir::CallExpression *callExpr, ArenaVector const &signatures, + ArenaVector &arguments); + bool SetPreferredTypeBeforeValidate(Signature *substitutedSig, ir::Expression *argument, size_t index, + TypeRelationFlag flags, const std::vector &argTypeInferenceRequired); + // CC-OFFNXT(G.FUN.01-CPP) solid logic Signature *ValidateSignatures(ArenaVector &signatures, const ir::TSTypeParameterInstantiation *typeArguments, @@ -666,6 +693,7 @@ public: static bool IsVariableStatic(const varbinder::Variable *var); static bool IsVariableGetterSetter(const varbinder::Variable *var); static bool IsVariableExtensionAccessor(const varbinder::Variable *var); + static bool IsVariableOverloadDeclaration(const varbinder::Variable *var); bool IsSameDeclarationType(varbinder::LocalVariable *target, varbinder::LocalVariable *compare); void SaveCapturedVariable(varbinder::Variable *var, ir::Identifier *ident); bool SaveCapturedVariableInLocalClass(varbinder::Variable *var, ir::Identifier *ident); @@ -683,6 +711,12 @@ public: ir::BlockStatement *FindFinalizerOfTryStatement(ir::AstNode *startFrom, const ir::AstNode *p); void CheckExceptionClauseType(const std::vector &exceptions, ir::CatchClause *catchClause, checker::Type *clauseType); + + void CheckConstructorOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const; + void CheckFunctionOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const; + void CheckClassMethodOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const; + void CheckInterfaceMethodOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const; + ETSObjectType *GetRelevantArgumentedTypeFromChild(ETSObjectType *child, ETSObjectType *target); util::StringView GetHashFromTypeArguments(const ArenaVector &typeArgTypes); util::StringView GetHashFromSubstitution(const Substitution *substitution, const bool isExtensionFuncFlag); @@ -978,6 +1012,7 @@ private: PropertySearchFlags GetInitialSearchFlags(const ir::MemberExpression *memberExpr); const varbinder::Variable *GetTargetRef(const ir::MemberExpression *memberExpr); Type *GetTypeOfSetterGetter([[maybe_unused]] varbinder::Variable *var); + ETSFunctionType *CreateSyntheticTypeFromOverload(varbinder::Variable *const var); void IterateInVariableContext([[maybe_unused]] varbinder::Variable *const var); bool CheckInit(ir::Identifier *ident, ir::TypeNode *typeAnnotation, ir::Expression *init, checker::Type *annotationType, varbinder::Variable *const bindingVar); diff --git a/ets2panda/checker/SemanticAnalyzer.h b/ets2panda/checker/SemanticAnalyzer.h index db3d9007a8..1126ba93c0 100644 --- a/ets2panda/checker/SemanticAnalyzer.h +++ b/ets2panda/checker/SemanticAnalyzer.h @@ -27,6 +27,7 @@ #include "ir/base/decorator.h" #include "ir/base/metaProperty.h" #include "ir/base/methodDefinition.h" +#include "ir/base/overloadDeclaration.h" #include "ir/base/property.h" #include "ir/base/scriptFunction.h" #include "ir/base/spreadElement.h" diff --git a/ets2panda/checker/TSAnalyzerUnreachable.cpp b/ets2panda/checker/TSAnalyzerUnreachable.cpp index 8b0a749ef1..43a987d1cb 100644 --- a/ets2panda/checker/TSAnalyzerUnreachable.cpp +++ b/ets2panda/checker/TSAnalyzerUnreachable.cpp @@ -48,6 +48,11 @@ checker::Type *TSAnalyzer::Check([[maybe_unused]] ir::MethodDefinition *node) co ES2PANDA_UNREACHABLE(); } +checker::Type *TSAnalyzer::Check([[maybe_unused]] ir::OverloadDeclaration *node) const +{ + ES2PANDA_UNREACHABLE(); +} + checker::Type *TSAnalyzer::Check([[maybe_unused]] ir::Property *expr) const { ES2PANDA_UNREACHABLE(); diff --git a/ets2panda/checker/checker.h b/ets2panda/checker/checker.h index e3ae34e684..04d1c37692 100644 --- a/ets2panda/checker/checker.h +++ b/ets2panda/checker/checker.h @@ -483,6 +483,42 @@ private: Type *type_ {}; }; +class SignatureMatchContext { +public: + explicit SignatureMatchContext(Checker *checker, util::DiagnosticType diagnosticKind, bool isLogError = true) + : diagnosticEngine_(checker->DiagnosticEngine()), + diagnosticCheckpoint_(), + diagnosticKind_(diagnosticKind), + isLogError_(isLogError) + { + diagnosticCheckpoint_ = diagnosticEngine_.Save(); + } + + bool ValidSignatureMatchStatus() + { + std::array diagnosticCheckpoint = diagnosticEngine_.Save(); + return diagnosticCheckpoint_[diagnosticKind_] == diagnosticCheckpoint[diagnosticKind_]; + } + + ~SignatureMatchContext() + { + if (isLogError_) { + return; + } + + diagnosticEngine_.Rollback(diagnosticCheckpoint_); + } + + NO_COPY_SEMANTIC(SignatureMatchContext); + NO_MOVE_SEMANTIC(SignatureMatchContext); + +private: + util::DiagnosticEngine &diagnosticEngine_; + std::array diagnosticCheckpoint_; + util::DiagnosticType diagnosticKind_; + bool isLogError_; +}; + } // namespace ark::es2panda::checker #endif /* CHECKER_H */ diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp index 3e78b0fc52..7740649e4c 100644 --- a/ets2panda/checker/ets/function.cpp +++ b/ets2panda/checker/ets/function.cpp @@ -396,13 +396,13 @@ static void ClearPreferredTypeForArray(checker::ETSChecker *checker, ir::Express { if (argument->IsArrayExpression()) { // fixed array and resizeable array will cause problem here, so clear it. - argument->AsArrayExpression()->ClearPreferredType(); + argument->AsArrayExpression()->CleanCheckInformation(); argument->AsArrayExpression()->SetPreferredTypeBasedOnFuncParam(checker, paramType, flags); } else if (argument->IsETSNewArrayInstanceExpression()) { - argument->AsETSNewArrayInstanceExpression()->ClearPreferredType(); + argument->AsETSNewArrayInstanceExpression()->CleanCheckInformation(); argument->AsETSNewArrayInstanceExpression()->SetPreferredTypeBasedOnFuncParam(checker, paramType, flags); } else if (argument->IsETSNewMultiDimArrayInstanceExpression()) { - argument->AsETSNewMultiDimArrayInstanceExpression()->ClearPreferredType(); + argument->AsETSNewMultiDimArrayInstanceExpression()->CleanCheckInformation(); argument->AsETSNewMultiDimArrayInstanceExpression()->SetPreferredTypeBasedOnFuncParam(checker, paramType, flags); } else { @@ -1289,6 +1289,7 @@ void ETSChecker::UpdateDeclarationFromSignature(ir::CallExpression *expr, checke auto newDecl = allocator->New(allocator, sigName, declNode); auto newVar = allocator->New(newDecl, varbinder::VariableFlags::METHOD | varbinder::VariableFlags::SYNTHETIC); + newVar->SetTsType(declNode->AsMethodDefinition()->TsType()->Clone(this)); callIdentifier->SetVariable(newVar); } @@ -1360,6 +1361,12 @@ Signature *ETSChecker::ResolveCallExpressionAndTrailingLambda(ArenaVector &arguments, const lexer::SourcePosition &pos) { + auto *var = type->GetProperty(compiler::Signatures::CONSTRUCTOR_OVERLOAD_DEFINITION_NAME, + PropertySearchFlags::SEARCH_STATIC_METHOD); + if (var != nullptr && var->TsType()->IsETSFunctionType()) { + return MatchOrderSignatures(var->TsType()->AsETSFunctionType()->CallSignatures(), nullptr, arguments, pos, + TypeRelationFlag::NONE); + } // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) return ValidateSignatures(type->ConstructSignatures(), nullptr, arguments, pos, "construct"); } @@ -2497,4 +2504,324 @@ bool ETSChecker::HasSameAssemblySignatures(ETSFunctionType const *const func1, return false; } +Signature *ETSChecker::FirstMatchSignatures(ir::CallExpression *expr, checker::Type *calleeType) +{ + if (expr->TrailingBlock() == nullptr) { + auto *signature = + MatchOrderSignatures(calleeType->AsETSFunctionType()->CallSignaturesOfMethodOrArrow(), expr->TypeParams(), + expr->Arguments(), expr->Start(), TypeRelationFlag::NONE); + if (signature == nullptr) { + ThrowOverloadMismatch(calleeType->AsETSFunctionType()->Name(), expr->Arguments(), expr->Start(), "call"); + return nullptr; + } + UpdateDeclarationFromSignature(expr, signature); + return signature; + } + + auto &signatures = expr->IsETSConstructorCall() ? calleeType->AsETSObjectType()->ConstructSignatures() + : calleeType->AsETSFunctionType()->CallSignaturesOfMethodOrArrow(); + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + return ResolveTrailingLambda(signatures, expr, expr->Start()); +} + +Signature *ETSChecker::MatchOrderSignatures(ArenaVector &signatures, + const ir::TSTypeParameterInstantiation *typeArguments, + const ArenaVector &arguments, + const lexer::SourcePosition &pos, TypeRelationFlag resolveFlags) +{ + Signature *compatibleSignatures = nullptr; + Signature *notVisibleSignature = nullptr; + std::vector argTypeInferenceRequired = FindTypeInferenceArguments(arguments); + + auto collectSignatures = [&](TypeRelationFlag relationFlags) { + for (auto *sig : signatures) { + if (notVisibleSignature != nullptr && + !IsSignatureAccessible(sig, Context().ContainingClass(), Relation())) { + continue; + } + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + auto *concreteSig = ValidateOrderSignature(std::make_tuple(sig, typeArguments, relationFlags), arguments, + pos, argTypeInferenceRequired, signatures.size() == 1); + + if (concreteSig == nullptr) { + CleanArgumentsInformation(arguments); + continue; + } + if (notVisibleSignature == nullptr && + !IsSignatureAccessible(sig, Context().ContainingClass(), Relation())) { + CleanArgumentsInformation(arguments); + notVisibleSignature = concreteSig; + } else { + compatibleSignatures = concreteSig; + return; + } + } + }; + + collectSignatures(signatures.size() == 1 ? TypeRelationFlag::WIDENING | resolveFlags + : TypeRelationFlag::WIDENING | TypeRelationFlag::NO_THROW | resolveFlags); + + if (compatibleSignatures != nullptr) { + return compatibleSignatures; + } + + if (notVisibleSignature != nullptr && ((resolveFlags & TypeRelationFlag::NO_THROW) == 0)) { + LogError(diagnostic::SIG_INVISIBLE, {notVisibleSignature->Function()->Id()->Name(), notVisibleSignature}, pos); + } + + return nullptr; +} + +Signature *ETSChecker::ValidateOrderSignature( + std::tuple info, + const ArenaVector &arguments, const lexer::SourcePosition &pos, + const std::vector &argTypeInferenceRequired, const bool unique) +{ + auto [baseSignature, typeArguments, flags] = info; + // In case of overloads, it is necessary to iterate through the compatible signatures again, + // setting the boxing/unboxing flag for the arguments if needed. + // So handle substitution arguments only in the case of unique function or collecting signature phase. + Signature *const signature = + MaybeSubstituteTypeParameters(this, baseSignature, typeArguments, arguments, pos, flags); + if (signature == nullptr) { + return nullptr; + } + + // When process first match, if current signature is not matched, do not log TypeError + SignatureMatchContext signatureMatchContext(this, util::DiagnosticType::SEMANTIC, + (flags & TypeRelationFlag::NO_THROW) == 0); + + size_t const argCount = arguments.size(); + auto const hasRestParameter = signature->RestVar() != nullptr; + size_t compareCount = argCount; + if ((flags & TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA) != 0 && !signature->Params().empty() && + signature->Params().back()->Declaration()->Node()->AsETSParameterExpression()->IsOptional()) { + compareCount = compareCount - 1; + } + + if (compareCount < signature->MinArgCount() || (argCount > signature->ArgCount() && !hasRestParameter)) { + LogError(diagnostic::PARAM_COUNT_MISMATCH, {signature->MinArgCount(), argCount}, pos); + return nullptr; + } + + if (argCount > signature->ArgCount() && hasRestParameter && (flags & TypeRelationFlag::IGNORE_REST_PARAM) != 0) { + return nullptr; + } + + auto count = std::min(signature->ArgCount(), argCount); + // Check all required formal parameter(s) first + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + if (!ValidateOrderSignatureRequiredParams(signature, arguments, flags, argTypeInferenceRequired) || + !signatureMatchContext.ValidSignatureMatchStatus()) { + return nullptr; + } + + // Check rest parameter(s) if any exists + if (!hasRestParameter || (count >= argCount && !signature->RestVar()->TsType()->IsETSTupleType())) { + return signature; + } + if (!ValidateSignatureRestParams(signature, arguments, flags, true, unique)) { + return nullptr; + } + + return signature; +} + +bool ETSChecker::SetPreferredTypeBeforeValidate(Signature *substitutedSig, ir::Expression *argument, size_t index, + TypeRelationFlag flags, + const std::vector &argTypeInferenceRequired) +{ + auto const paramType = GetNonNullishType(substitutedSig->Params()[index]->TsType()); + if (argument->IsObjectExpression()) { + argument->AsObjectExpression()->SetPreferredType(paramType); + } + + if (argument->IsMemberExpression()) { + SetArrayPreferredTypeForNestedMemberExpressions(argument->AsMemberExpression(), paramType); + } + + if (argTypeInferenceRequired[index]) { + if (!paramType->IsETSFunctionType()) { + return false; + } + ES2PANDA_ASSERT(argument->IsArrowFunctionExpression()); + auto *param = substitutedSig->Params()[index]->Declaration()->Node()->AsETSParameterExpression(); + auto *lambda = argument->AsArrowFunctionExpression(); + if (lambda->Function()->Params().size() > + paramType->AsETSFunctionType()->CallSignaturesOfMethodOrArrow().front()->Params().size()) { + return false; + } + return CheckLambdaInfer(param->TypeAnnotation(), argument->AsArrowFunctionExpression(), paramType); + } + + if (argument->IsArrayExpression()) { + argument->AsArrayExpression()->SetPreferredTypeBasedOnFuncParam(this, paramType, flags); + } + + if (argument->IsETSNewArrayInstanceExpression()) { + argument->AsETSNewArrayInstanceExpression()->SetPreferredTypeBasedOnFuncParam(this, paramType, flags); + } + + if (argument->IsETSNewMultiDimArrayInstanceExpression()) { + argument->AsETSNewMultiDimArrayInstanceExpression()->SetPreferredTypeBasedOnFuncParam(this, paramType, flags); + } + + return true; +} + +bool ETSChecker::ValidateOrderSignatureRequiredParams(Signature *substitutedSig, + const ArenaVector &arguments, + TypeRelationFlag flags, + const std::vector &argTypeInferenceRequired) +{ + auto commonArity = std::min(arguments.size(), substitutedSig->ArgCount()); + if ((flags & TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA) != 0) { + commonArity = commonArity - 1; + } + for (size_t index = 0; index < commonArity; ++index) { + auto &argument = arguments[index]; + if (!SetPreferredTypeBeforeValidate(substitutedSig, argument, index, flags, argTypeInferenceRequired)) { + return false; + } + + if (argument->IsSpreadElement()) { + LogError(diagnostic::SPREAD_ONTO_SINGLE_PARAM, {}, argument->Start()); + return false; + } + + if (argument->IsIdentifier() && ValidateArgumentAsIdentifier(argument->AsIdentifier())) { + LogError(diagnostic::ARG_IS_CLASS_ID, {}, argument->Start()); + return false; + } + + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + if (!ValidateOrderSignatureInvocationContext(substitutedSig, argument, index, flags)) { + return false; + } + } + + if ((flags & TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA) != 0 && arguments.back()->IsArrowFunctionExpression()) { + ir::ScriptFunction *const lambda = arguments.back()->AsArrowFunctionExpression()->Function(); + auto targetParm = substitutedSig->GetSignatureInfo()->params.back()->Declaration()->Node(); + if (!CheckLambdaAssignable(targetParm->AsETSParameterExpression(), lambda)) { + return false; + } + } + return true; +} + +void ETSChecker::CleanArgumentsInformation(const ArenaVector &arguments) +{ + if (arguments.empty()) { + return; + } + for (auto *argument : arguments) { + argument->CleanCheckInformation(); + } +} + +bool ETSChecker::ValidateOrderSignatureInvocationContext(Signature *substitutedSig, ir::Expression *argument, + std::size_t index, TypeRelationFlag flags) +{ + Type *targetType = substitutedSig->Params()[index]->TsType(); + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + Type *argumentType = argument->Check(this); + + flags |= TypeRelationFlag::ONLY_CHECK_WIDENING; + + auto const invocationCtx = + checker::InvocationContext(Relation(), argument, argumentType, targetType, argument->Start(), + {{diagnostic::TYPE_MISMATCH_AT_IDX, {argumentType, targetType, index + 1}}}, flags); + + return invocationCtx.IsInvocable(); +} + +Signature *ETSChecker::ResolveTrailingLambda(ArenaVector &signatures, ir::CallExpression *callExpr, + const lexer::SourcePosition &pos, const TypeRelationFlag reportFlag) +{ + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + auto arguments = ExtendArgumentsWithFakeLamda(callExpr); + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + auto sig = ResolvePotentialTrailingLambda(callExpr, signatures, arguments); + if (sig != nullptr) { + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + TransformTraillingLambda(callExpr, sig); + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + TrailingLambdaTypeInference(sig, callExpr->Arguments()); + UpdateDeclarationFromSignature(callExpr, sig); + callExpr->SetIsTrailingCall(true); + return sig; + } + + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + sig = MatchOrderSignatures(signatures, callExpr->TypeParams(), callExpr->Arguments(), pos, reportFlag); + if (sig != nullptr) { + EnsureValidCurlyBrace(callExpr); + } + + UpdateDeclarationFromSignature(callExpr, sig); + return sig; +} + +Signature *ETSChecker::ResolvePotentialTrailingLambda(ir::CallExpression *callExpr, + ArenaVector const &signatures, + ArenaVector &arguments) +{ + auto *trailingLambda = arguments.back()->AsArrowFunctionExpression(); + ArenaVector normalSig(ProgramAllocator()->Adapter()); + ArenaVector sigContainLambdaWithReceiverAsParam(ProgramAllocator()->Adapter()); + Signature *signature = nullptr; + for (auto sig : signatures) { + if (!IsLastParameterLambdaWithReceiver(sig)) { + normalSig.emplace_back(sig); + continue; + } + + auto *candidateFunctionType = + sig->Function()->Params().back()->AsETSParameterExpression()->TypeAnnotation()->AsETSFunctionType(); + auto *currentReceiver = candidateFunctionType->Params()[0]; + trailingLambda->Function()->EmplaceParams(currentReceiver); + sigContainLambdaWithReceiverAsParam.emplace_back(sig); + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + signature = MatchOrderSignatures(sigContainLambdaWithReceiverAsParam, callExpr->TypeParams(), arguments, + callExpr->Start(), + TypeRelationFlag::NO_THROW | TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA); + if (signature != nullptr) { + return signature; + } + sigContainLambdaWithReceiverAsParam.clear(); + trailingLambda->Function()->ClearParams(); + } + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + return MatchOrderSignatures(normalSig, callExpr->TypeParams(), arguments, callExpr->Start(), + TypeRelationFlag::NO_THROW | TypeRelationFlag::NO_CHECK_TRAILING_LAMBDA); +} + +void ETSChecker::ThrowOverloadMismatch(util::StringView callName, const ArenaVector &arguments, + const lexer::SourcePosition &pos, std::string_view signatureKind) +{ + std::string msg {}; + msg.append(callName.Mutf8()); + msg += "("; + + for (std::size_t index = 0U; index < arguments.size(); ++index) { + auto const &argument = arguments[index]; + Type const *const argumentType = argument->Check(this); + if (!argumentType->IsTypeError()) { + msg += argumentType->ToString(); + } else { + // NOTE (DZ): extra cases for some specific nodes can be added here (as for 'ArrowFunctionExpression') + msg += argument->ToString(); + } + + if (index == arguments.size() - 1U) { + msg += ")"; + LogError(diagnostic::NO_MATCHING_SIG, {signatureKind, msg.c_str()}, pos); + return; + } + + msg += ", "; + } +} + } // namespace ark::es2panda::checker diff --git a/ets2panda/checker/ets/helpers.cpp b/ets2panda/checker/ets/helpers.cpp index 2886671c98..d5781e2b7c 100644 --- a/ets2panda/checker/ets/helpers.cpp +++ b/ets2panda/checker/ets/helpers.cpp @@ -72,6 +72,12 @@ bool ETSChecker::IsVariableGetterSetter(const varbinder::Variable *var) return var != nullptr && var->TsType() != nullptr && var->TsType()->HasTypeFlag(TypeFlag::GETTER_SETTER); } +bool ETSChecker::IsVariableOverloadDeclaration(const varbinder::Variable *var) +{ + return var != nullptr && var->Declaration() != nullptr && var->Declaration()->Node() != nullptr && + var->Declaration()->Node()->IsOverloadDeclaration(); +} + bool ETSChecker::IsVariableExtensionAccessor(const varbinder::Variable *var) { return var != nullptr && var->TsType() != nullptr && var->TsType()->IsETSFunctionType() && @@ -314,6 +320,10 @@ Type *ETSChecker::ResolveIdentifier(ir::Identifier *ident) ValidatePropertyAccess(resolved, Context().ContainingClass(), ident->Start()); SaveCapturedVariable(resolved, ident); + if (IsVariableOverloadDeclaration(resolved)) { + return CreateSyntheticTypeFromOverload(resolved); + } + return GetTypeOfVariable(resolved); } diff --git a/ets2panda/checker/ets/object.cpp b/ets2panda/checker/ets/object.cpp index 3c0ab334a3..2a283129c7 100644 --- a/ets2panda/checker/ets/object.cpp +++ b/ets2panda/checker/ets/object.cpp @@ -82,8 +82,35 @@ static bool CheckGetterSetterDecl(varbinder::LocalVariable const *child, varbind return checkChild && checkParent && (child->TsType()->IsETSFunctionType() || parent->TsType()->IsETSFunctionType()); } +static bool CheckOverloadDecl(varbinder::LocalVariable *child, varbinder::LocalVariable *parent) +{ + if (!child->Declaration()->Node()->IsOverloadDeclaration() || + !parent->Declaration()->Node()->IsOverloadDeclaration()) { + return false; + } + + auto *childOverload = child->Declaration()->Node()->AsOverloadDeclaration(); + auto *parentOverload = parent->Declaration()->Node()->AsOverloadDeclaration(); + for (auto *baseMethodName : parentOverload->OverloadedList()) { + ES2PANDA_ASSERT(baseMethodName->IsIdentifier()); + auto res = std::find_if(childOverload->OverloadedList().begin(), childOverload->OverloadedList().end(), + [baseMethodName](ir::Expression *subMethodName) { + return subMethodName->IsIdentifier() && subMethodName->AsIdentifier()->Name() == + baseMethodName->AsIdentifier()->Name(); + }); + if (res == childOverload->OverloadedList().end()) { + return false; + } + } + return true; +} + static bool CheckFunctionDecl(varbinder::LocalVariable *child, varbinder::LocalVariable *parent) { + if (child->Declaration()->Node()->IsOverloadDeclaration() || + parent->Declaration()->Node()->IsOverloadDeclaration()) { + return false; + } ES2PANDA_ASSERT(child->Declaration()->Type() == parent->Declaration()->Type()); if (!child->TsType()->IsETSMethodType()) { return true; @@ -565,49 +592,57 @@ static void ResolveDeclaredMethodsOfObject(ETSChecker *checker, const ETSObjectT { for (auto &[_, it] : scope->InstanceMethodScope()->Bindings()) { (void)_; - auto *method = it->Declaration()->Node()->AsMethodDefinition(); - auto *function = method->Function(); - if (function->IsProxy()) { - continue; - } + if (it->Declaration()->Node()->IsMethodDefinition()) { + auto *method = it->Declaration()->Node()->AsMethodDefinition(); + auto *function = method->Function(); + if (function->IsProxy()) { + continue; + } - it->AddFlag(checker->GetAccessFlagFromNode(method)); - auto *funcType = checker->BuildMethodSignature(method); - if (!funcType->IsTypeError()) { - funcType->SetVariable(it); + it->AddFlag(checker->GetAccessFlagFromNode(method)); + auto *funcType = checker->BuildMethodSignature(method); + if (!funcType->IsTypeError()) { + funcType->SetVariable(it); + } + it->SetTsType(funcType); + method->SetTsType(funcType); + type->AddProperty(it->AsLocalVariable()); + } else if (it->Declaration()->Node()->IsOverloadDeclaration()) { + type->AddProperty(it->AsLocalVariable()); + } else { + ES2PANDA_UNREACHABLE(); } - it->SetTsType(funcType); - method->SetTsType(funcType); - type->AddProperty(it->AsLocalVariable()); } for (auto &[_, it] : scope->StaticMethodScope()->Bindings()) { (void)_; - if (!it->Declaration()->Node()->IsMethodDefinition()) { - continue; - } + if (it->Declaration()->Node()->IsMethodDefinition()) { + auto *method = it->Declaration()->Node()->AsMethodDefinition(); + auto *function = method->Function(); - auto *method = it->Declaration()->Node()->AsMethodDefinition(); - auto *function = method->Function(); + if (function->IsProxy()) { + continue; + } - if (function->IsProxy()) { - continue; - } + it->AddFlag(checker->GetAccessFlagFromNode(method)); + auto *funcType = checker->BuildMethodSignature(method); + if (!funcType->IsTypeError()) { + funcType->SetVariable(it); + } + it->SetTsType(funcType); + method->SetTsType(funcType); - it->AddFlag(checker->GetAccessFlagFromNode(method)); - auto *funcType = checker->BuildMethodSignature(method); - if (!funcType->IsTypeError()) { - funcType->SetVariable(it); - } - it->SetTsType(funcType); - method->SetTsType(funcType); + if (method->IsConstructor() && funcType->IsETSFunctionType()) { + type->AddConstructSignature(funcType->AsETSFunctionType()->CallSignatures()); + continue; + } - if (method->IsConstructor() && funcType->IsETSFunctionType()) { - type->AddConstructSignature(funcType->AsETSFunctionType()->CallSignatures()); + type->AddProperty(it->AsLocalVariable()); + } else if (it->Declaration()->Node()->IsOverloadDeclaration()) { + type->AddProperty(it->AsLocalVariable()); + } else { continue; } - - type->AddProperty(it->AsLocalVariable()); } } @@ -715,6 +750,10 @@ std::vector ETSChecker::CollectAbstractSignaturesFromObject(const E { std::vector abstracts; for (const auto &prop : objType->Methods()) { + if (prop->Declaration()->Node()->IsOverloadDeclaration()) { + continue; + } + GetTypeOfVariable(prop); if (!prop->TsType()->IsETSFunctionType()) { @@ -913,6 +952,10 @@ void ETSChecker::CheckInterfaceFunctions(ETSObjectType *classType) for (auto *const &interface : interfaces) { for (auto *const &prop : interface->Methods()) { + if (prop->Declaration()->Node()->IsOverloadDeclaration()) { + continue; + } + ir::MethodDefinition *node = prop->Declaration()->Node()->AsMethodDefinition(); if (prop->TsType()->IsTypeError()) { continue; @@ -1935,6 +1978,10 @@ PropertySearchFlags ETSChecker::GetInitialSearchFlags(const ir::MemberExpression } break; } + case ir::AstNodeType::OVERLOAD_DECLARATION: { + return FUNCTIONAL_FLAGS | GETTER_FLAGS; + break; + } case ir::AstNodeType::ETS_NEW_CLASS_INSTANCE_EXPRESSION: { if (memberExpr->Parent()->AsETSNewClassInstanceExpression()->GetTypeRef() == memberExpr) { return PropertySearchFlags::SEARCH_DECL; @@ -2249,6 +2296,17 @@ std::vector ETSChecker::ResolveMemberReference(const ir::Member return resolveRes; } +varbinder::LocalVariable *ETSChecker::ResolveOverloadReference(const ir::Identifier *ident, ETSObjectType *objType, + PropertySearchFlags searchFlags) +{ + auto *var = objType->GetProperty(ident->Name(), searchFlags); + if (var == nullptr) { + return nullptr; + } + ValidatePropertyAccess(var, objType, ident->Start()); + return var; +} + void ETSChecker::WarnForEndlessLoopInGetterSetter(const ir::MemberExpression *const memberExpr) { if (!memberExpr->Object()->IsThisExpression() || memberExpr->Property() == nullptr || @@ -2329,6 +2387,8 @@ void ETSChecker::CheckProperties(ETSObjectType *classType, ir::ClassDefinition * if (CheckGetterSetterDecl(it, found)) { return; } + } else if (CheckOverloadDecl(it, found)) { + return; } else if (CheckFunctionDecl(it, found)) { return; } @@ -2347,6 +2407,8 @@ void ETSChecker::CheckProperties(ETSObjectType *classType, ir::ClassDefinition * targetType = "namespace"; } else if (it->HasFlag(varbinder::VariableFlags::ENUM_LITERAL)) { targetType = "enum"; + } else if (it->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + targetType = "overload"; } else { ES2PANDA_UNREACHABLE(); } diff --git a/ets2panda/checker/ets/typeCheckingHelpers.cpp b/ets2panda/checker/ets/typeCheckingHelpers.cpp index 77d3cf08eb..7fae85b785 100644 --- a/ets2panda/checker/ets/typeCheckingHelpers.cpp +++ b/ets2panda/checker/ets/typeCheckingHelpers.cpp @@ -477,6 +477,30 @@ Type *ETSChecker::GetTypeOfSetterGetter(varbinder::Variable *const var) return propType->FindSetter()->Params()[0]->TsType(); } +ETSFunctionType *ETSChecker::CreateSyntheticTypeFromOverload(varbinder::Variable *const var) +{ + auto *overloadDeclaration = var->Declaration()->Node()->AsOverloadDeclaration(); + std::vector signatures; + ETSFunctionType *syntheticFunctionType = + CreateETSMethodType(overloadDeclaration->Id()->Name(), {{}, Allocator()->Adapter()}); + + for (auto *overloadFunction : overloadDeclaration->OverloadedList()) { + Type *functionType = overloadFunction->Check(this); + ES2PANDA_ASSERT(functionType->IsETSFunctionType()); + auto *signature = functionType->AsETSFunctionType()->CallSignatures().front(); + if (std::find(signatures.begin(), signatures.end(), signature) != signatures.end()) { + continue; + } + signatures.emplace_back(signature); + } + + for (auto &s : signatures) { + syntheticFunctionType->AddCallSignature(s); + } + + return syntheticFunctionType; +} + void ETSChecker::IterateInVariableContext(varbinder::Variable *const var) { // Before computing the given variables type, we have to make a new checker context frame so that the checking is @@ -1619,4 +1643,180 @@ void ETSChecker::CheckExceptionClauseType(const std::vectorLogError(diagnostic::OVERLOAD_MODIFIERS_ABSTRACT, {}, pos); + return false; + } + + if (((overLoadAliasFlags ^ overloadedMethodFlags) & (ir::ModifierFlags::STATIC | ir::ModifierFlags::ASYNC)) != 0) { + checker->LogError(diagnostic::OVERLOAD_SAME_ACCESS_MODIFIERS_STATIC_ASYNC, {}, pos); + return false; + } + + if (((overLoadAliasFlags ^ overloadedMethodFlags) & (ir::ModifierFlags::CONSTRUCTOR)) != 0) { + checker->LogError(diagnostic::OVERLOAD_MUST_BOTH_CONSTRUCT, {}, pos); + return false; + } + + if ((overLoadAliasFlags & ir::ModifierFlags::EXPORT) != 0 && + (overloadedMethodFlags & ir::ModifierFlags::EXPORT) == 0) { + checker->LogError(diagnostic::OVERLOADED_NAME_MUST_ALSO_EXPORTED, {}, pos); + return false; + } + return true; +} + +static bool CheckOverloadedName(ETSChecker *checker, ir::OverloadDeclaration *node, ir::Expression *overloadedName) +{ + if (overloadedName->Variable()->Declaration() == nullptr) { + checker->LogError(diagnostic::OVERLOADED_NAME_MUST_FUNCTION, {}, overloadedName->Start()); + overloadedName->SetTsType(checker->GlobalTypeError()); + return false; + } + + auto *identDeclNode = overloadedName->Variable()->Declaration()->Node(); + if (!identDeclNode->IsMethodDefinition()) { + checker->LogError(diagnostic::OVERLOADED_NAME_MUST_FUNCTION, {}, overloadedName->Start()); + overloadedName->SetTsType(checker->GlobalTypeError()); + return false; + } + // Constructor will lowering to multiple Constructor if have rest parameters or optional parameters. + // Need to modify RestTupleConstructionPhase. + if (!identDeclNode->AsMethodDefinition()->Overloads().empty() && !identDeclNode->IsConstructor()) { + checker->LogError(diagnostic::OVERLOADED_NAME_REFER_TO_OVERLOAD_FUNCTION, {overloadedName->Variable()->Name()}, + overloadedName->Start()); + overloadedName->SetTsType(checker->GlobalTypeError()); + return false; + } + + return CheckAccessModifierForOverloadDeclaration(checker, node->Modifiers(), identDeclNode->Modifiers(), + overloadedName->Start()); +} + +void ETSChecker::CheckFunctionOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const +{ + for (auto *overloadedName : node->OverloadedList()) { + if (overloadedName->IsMemberExpression()) { + overloadedName->Check(checker); + overloadedName->SetVariable(overloadedName->AsMemberExpression()->Property()->Variable()); + } else if (overloadedName->IsIdentifier()) { + ir::Identifier *ident = overloadedName->AsIdentifier(); + + Type *classType = node->Parent()->AsClassDefinition()->TsType(); + ES2PANDA_ASSERT(classType->IsETSObjectType()); + + PropertySearchFlags searchFlags = PropertySearchFlags::SEARCH_METHOD | PropertySearchFlags::SEARCH_IN_BASE | + PropertySearchFlags::SEARCH_IN_INTERFACES | + PropertySearchFlags::IS_GETTER; + auto *variable = + checker->ResolveOverloadReference(ident->AsIdentifier(), classType->AsETSObjectType(), searchFlags); + if (variable == nullptr) { + checker->LogError(diagnostic::OVERLOADED_NAME_MUST_FUNCTION, {}, ident->Start()); + ident->SetTsType(checker->GlobalTypeError()); + continue; + } + + ident->SetTsType(variable->TsType()); + ident->SetVariable(variable); + + if (!CheckOverloadedName(checker, node, overloadedName)) { + continue; + } + } else { + overloadedName->SetTsType(checker->GlobalTypeError()); + continue; + } + } +} + +void ETSChecker::CheckClassMethodOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const +{ + for (auto *overloadedName : node->OverloadedList()) { + if (!overloadedName->IsIdentifier()) { + overloadedName->SetTsType(checker->GlobalTypeError()); + continue; + } + ir::Identifier *ident = overloadedName->AsIdentifier(); + + Type *classType = node->Parent()->AsClassDefinition()->TsType(); + ES2PANDA_ASSERT(classType->IsETSObjectType()); + + PropertySearchFlags searchFlags = PropertySearchFlags::SEARCH_METHOD | PropertySearchFlags::SEARCH_IN_BASE | + PropertySearchFlags::SEARCH_IN_INTERFACES | PropertySearchFlags::IS_GETTER; + auto *variable = + checker->ResolveOverloadReference(ident->AsIdentifier(), classType->AsETSObjectType(), searchFlags); + if (variable == nullptr) { + checker->LogError(diagnostic::OVERLOADED_NAME_MUST_FUNCTION, {}, ident->Start()); + ident->SetTsType(checker->GlobalTypeError()); + continue; + } + + ident->SetTsType(variable->TsType()); + ident->SetVariable(variable); + + if (!CheckOverloadedName(checker, node, overloadedName)) { + continue; + } + } +} + +void ETSChecker::CheckInterfaceMethodOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const +{ + for (auto *overloadedName : node->OverloadedList()) { + if (!overloadedName->IsIdentifier()) { + overloadedName->SetTsType(checker->GlobalTypeError()); + continue; + } + ir::Identifier *ident = overloadedName->AsIdentifier(); + + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + Type *identType = checker->ResolveIdentifier(ident); + ident->SetTsType(identType); + if (!CheckOverloadedName(checker, node, overloadedName)) { + continue; + } + } +} + +void ETSChecker::CheckConstructorOverloadDeclaration(ETSChecker *checker, ir::OverloadDeclaration *node) const +{ + for (auto *overloadedName : node->OverloadedList()) { + if (!overloadedName->IsIdentifier()) { + overloadedName->SetTsType(checker->GlobalTypeError()); + continue; + } + ir::Identifier *ident = overloadedName->AsIdentifier(); + + // SUPPRESS_CSA_NEXTLINE(alpha.core.AllocatorETSCheckerHint) + Type *identType = checker->ResolveIdentifier(ident->AsIdentifier()); + ident->SetTsType(identType); + if (identType->IsTypeError()) { + continue; + } + + ES2PANDA_ASSERT(identType->IsETSFunctionType()); + const size_t singleSignatureSize = 1; + if (identType->AsETSFunctionType()->CallSignatures().size() > singleSignatureSize) { + size_t userDefinedConstructorSize = + std::count_if(identType->AsETSFunctionType()->CallSignatures().begin(), + identType->AsETSFunctionType()->CallSignatures().end(), + [](Signature *sig) { return !sig->Function()->IsSynthetic(); }); + if (userDefinedConstructorSize > singleSignatureSize) { + checker->LogError(diagnostic::OVERLOADED_NAME_REFER_TO_OVERLOAD_FUNCTION, {ident->Name()}, + node->Start()); + continue; + } + } + + if (!CheckOverloadedName(checker, node, overloadedName)) { + continue; + } + } +} + } // namespace ark::es2panda::checker diff --git a/ets2panda/checker/ets/validateHelpers.cpp b/ets2panda/checker/ets/validateHelpers.cpp index 685c1d8b4b..e944b05b04 100644 --- a/ets2panda/checker/ets/validateHelpers.cpp +++ b/ets2panda/checker/ets/validateHelpers.cpp @@ -64,6 +64,10 @@ void ETSChecker::ValidateCallExpressionIdentifier(ir::Identifier *const ident, T } ES2PANDA_ASSERT(ident->Variable() != nullptr); + if (ident->Variable()->Declaration()->Node() != nullptr && + ident->Variable()->Declaration()->Node()->IsOverloadDeclaration()) { + return; + } if (ident->Variable()->Declaration()->Node() != nullptr && ident->Variable()->Declaration()->Node()->IsImportNamespaceSpecifier()) { std::ignore = TypeError(ident->Variable(), diagnostic::NAMESPACE_CALL, {ident->ToString()}, ident->Start()); diff --git a/ets2panda/checker/types/ets/etsObjectType.cpp b/ets2panda/checker/types/ets/etsObjectType.cpp index 72c5694774..2a920a8376 100644 --- a/ets2panda/checker/types/ets/etsObjectType.cpp +++ b/ets2panda/checker/types/ets/etsObjectType.cpp @@ -25,10 +25,6 @@ namespace ark::es2panda::checker { -static std::multimap GetSignaturesForSyntheticType(ETSObjectType const *owner, - util::StringView name, - PropertySearchFlags flags); - void ETSObjectType::Iterate(const PropertyTraverser &cb) const { for (const auto *prop : GetAllProperties()) { @@ -212,7 +208,11 @@ static void UpdateDeclarationForGetterSetter(varbinder::LocalVariable *res, cons if (!HasAccessor(flags, funcType) || res->Declaration() != nullptr) { return; } - auto var = funcType->CallSignatures().front()->OwnerVar(); + + auto frontGetter = std::find_if(funcType->CallSignatures().begin(), funcType->CallSignatures().end(), + [](Signature *sig) { return sig->Function()->IsGetter(); }); + auto var = frontGetter == funcType->CallSignatures().end() ? funcType->CallSignatures().front()->OwnerVar() + : (*frontGetter)->OwnerVar(); auto decl = var->Declaration(); if (decl == nullptr || decl->Node() == nullptr) { return; @@ -220,20 +220,32 @@ static void UpdateDeclarationForGetterSetter(varbinder::LocalVariable *res, cons res->Reset(decl, var->Flags()); } -varbinder::LocalVariable *ETSObjectType::CreateSyntheticVarFromEverySignature(util::StringView name, +varbinder::LocalVariable *ETSObjectType::CreateSyntheticVarFromEverySignature(const util::StringView &name, PropertySearchFlags flags) const { - auto signatureSet = GetSignaturesForSyntheticType(this, name, flags); - if (signatureSet.empty()) { + std::vector signatures; + // Since both "first match" and "best match" exist at present, overloadDeclarationCall is temporarily used. After + // "best match" removed, this marking needs to be removed. + bool overloadDeclarationCall = false; + varbinder::LocalVariable *functionalInterface = + CollectSignaturesForSyntheticType(signatures, name, flags, overloadDeclarationCall); + // #22952: the called function *always* returns nullptr + ES2PANDA_ASSERT(functionalInterface == nullptr); + (void)functionalInterface; + + if (signatures.empty()) { return nullptr; } - varbinder::LocalVariable *res = allocator_->New(varbinder::VariableFlags::SYNTHETIC | - varbinder::VariableFlags::METHOD); + varbinder::VariableFlags varianceFlag = + overloadDeclarationCall ? varbinder::VariableFlags::SYNTHETIC | varbinder::VariableFlags::METHOD | + varbinder::VariableFlags::OVERLOAD + : varbinder::VariableFlags::SYNTHETIC | varbinder::VariableFlags::METHOD; + varbinder::LocalVariable *res = allocator_->New(varianceFlag); ETSFunctionType *funcType = CreateMethodTypeForProp(name); - for (auto &s : signatureSet) { - funcType->AddCallSignature(s.second); + for (auto &s : signatures) { + funcType->AddCallSignature(s); } res->SetTsType(funcType); funcType->SetVariable(res); @@ -249,89 +261,137 @@ ETSFunctionType *ETSObjectType::CreateMethodTypeForProp(util::StringView name) c return GetRelation()->GetChecker()->AsETSChecker()->CreateETSMethodType(name, {{}, Allocator()->Adapter()}); } -static void ReplaceArgInSig(std::multimap *signatureSet, Signature *sigToInsert, - TypeRelation *relation) +bool ETSObjectType::ReplaceArgumentInSignature(std::vector &signatures, Signature *sigToInsert, + TypeRelation *relation) const { - auto range = signatureSet->equal_range(sigToInsert->ArgCount()); - for (auto it = range.first; it != range.second; ++it) { - auto sigToReplace = it->second; - + for (auto *&sigToReplace : signatures) { + if (sigToReplace->ArgCount() != sigToInsert->ArgCount()) { + continue; + } if (relation->IsSupertypeOf(sigToInsert->Owner(), sigToReplace->Owner()) && relation->SignatureIsSupertypeOf(sigToInsert, sigToReplace)) { // Already overridden by a subtype's signature - return; + return true; } if (relation->IsSupertypeOf(sigToReplace->Owner(), sigToInsert->Owner()) && relation->SignatureIsSupertypeOf(sigToReplace, sigToInsert)) { - signatureSet->erase(it); - signatureSet->insert({sigToInsert->ArgCount(), sigToInsert}); - return; + sigToReplace = sigToInsert; + return true; } } - signatureSet->insert({sigToInsert->ArgCount(), sigToInsert}); + + return false; } -// CC-OFFNXT(huge_depth) solid logic -static void AddSignatureToSignatureSet(std::multimap *signatureSet, - varbinder::LocalVariable *found, TypeRelation *relation, - PropertySearchFlags flags) +void ETSObjectType::AddSignatureFromFunction(std::vector &signatures, PropertySearchFlags flags, + ETSChecker *checker, varbinder::LocalVariable *found) const { - for (auto *sigToInsert : found->TsType()->AsETSFunctionType()->CallSignatures()) { - if (((flags & PropertySearchFlags::IGNORE_ABSTRACT) != 0) && - sigToInsert->HasSignatureFlag(SignatureFlags::ABSTRACT)) { + for (auto *it : found->TsType()->AsETSFunctionType()->CallSignatures()) { + if (std::find(signatures.begin(), signatures.end(), it) != signatures.end()) { + continue; + } + if (((flags & PropertySearchFlags::IGNORE_ABSTRACT) != 0) && it->HasSignatureFlag(SignatureFlags::ABSTRACT)) { + continue; + } + if (ReplaceArgumentInSignature(signatures, it, checker->Relation())) { continue; } + signatures.emplace_back(it); + } +} - if (signatureSet->count(sigToInsert->ArgCount()) != 0U) { - ReplaceArgInSig(signatureSet, sigToInsert, relation); - } else { - signatureSet->insert({sigToInsert->ArgCount(), sigToInsert}); +void ETSObjectType::AddSignatureFromOverload(std::vector &signatures, PropertySearchFlags flags, + varbinder::LocalVariable *found, bool &overloadDeclarationCall) const +{ + auto *overloadDeclaration = found->Declaration()->Node()->AsOverloadDeclaration(); + std::vector methodSignature; + if (overloadDeclaration->Id()->IsErrorPlaceHolder()) { + return; + } + + overloadDeclarationCall |= true; + if (overloadDeclaration->IsConstructorOverloadDeclaration()) { + return AddSignatureFromConstructor(signatures, found); + } + + for (auto *method : overloadDeclaration->OverloadedList()) { + // Identical type cannot be obtained directly, because typeparamter has not been substitute. + methodSignature.clear(); + util::StringView methodName = + method->IsIdentifier() ? method->AsIdentifier()->Name() : method->AsTSQualifiedName()->Right()->Name(); + CollectSignaturesForSyntheticType(methodSignature, methodName, flags, overloadDeclarationCall); + if (!methodSignature.empty()) { + signatures.emplace_back(methodSignature.front()); } } } -static void CollectSignaturesForSyntheticType(ETSObjectType const *owner, - std::multimap *signatureSet, util::StringView name, - PropertySearchFlags flags) +void ETSObjectType::AddSignatureFromConstructor(std::vector &signatures, + varbinder::LocalVariable *found) const { - if ((flags & PropertySearchFlags::SEARCH_STATIC_METHOD) != 0) { - if (auto *found = owner->GetOwnProperty(name); - found != nullptr && !found->TsType()->IsTypeError()) { - ES2PANDA_ASSERT(found->TsType()->IsETSFunctionType()); - AddSignatureToSignatureSet(signatureSet, found, owner->GetRelation(), flags); + auto *overloadDeclaration = found->Declaration()->Node()->AsOverloadDeclaration(); + for (auto *method : overloadDeclaration->OverloadedList()) { + util::StringView orderConstructorName = method->AsIdentifier()->Name(); + + // Constructor will lowering to multiple Constructor if have rest parameters or optional parameters. + // Need to modify RestTupleConstructionPhase. + std::vector matches; + std::copy_if( + constructSignatures_.begin(), constructSignatures_.end(), std::back_inserter(matches), + [orderConstructorName](Signature *sig) { return sig->Function()->Id()->Name() == orderConstructorName; }); + + if (!matches.empty()) { + std::copy(matches.begin(), matches.end(), std::back_inserter(signatures)); } } +} - if ((flags & PropertySearchFlags::SEARCH_INSTANCE_METHOD) != 0) { - if (auto *found = owner->GetOwnProperty(name); - found != nullptr && !found->TsType()->IsTypeError()) { - ES2PANDA_ASSERT(found->TsType()->IsETSFunctionType()); - AddSignatureToSignatureSet(signatureSet, found, owner->GetRelation(), flags); +void ETSObjectType::AddSignature(std::vector &signatures, PropertySearchFlags flags, ETSChecker *checker, + varbinder::LocalVariable *found, bool &overloadDeclarationCall) const +{ + if (found != nullptr && found->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + if (!found->Declaration()->Node()->IsOverloadDeclaration()) { + return; } + AddSignatureFromOverload(signatures, flags, found, overloadDeclarationCall); + } else if (found != nullptr && !found->TsType()->IsTypeError()) { + ES2PANDA_ASSERT(found->TsType()->IsETSFunctionType()); + AddSignatureFromFunction(signatures, flags, checker, found); + } +} + +varbinder::LocalVariable *ETSObjectType::CollectSignaturesForSyntheticType(std::vector &signatures, + const util::StringView &name, + PropertySearchFlags flags, + bool &overloadDeclarationCall) const +{ + auto *checker = GetRelation()->GetChecker()->AsETSChecker(); + + if ((flags & PropertySearchFlags::SEARCH_STATIC_METHOD) != 0) { + auto *found = GetOwnProperty(name); + AddSignature(signatures, flags, checker, found, overloadDeclarationCall); + } + + if ((flags & PropertySearchFlags::SEARCH_INSTANCE_METHOD) != 0) { + auto *found = GetOwnProperty(name); + AddSignature(signatures, flags, checker, found, overloadDeclarationCall); } if ((flags & PropertySearchFlags::SEARCH_INSTANCE_METHOD) == 0) { - return; + return nullptr; } - if (owner->SuperType() != nullptr && ((flags & PropertySearchFlags::SEARCH_IN_BASE) != 0)) { - CollectSignaturesForSyntheticType(owner->SuperType(), signatureSet, name, flags); + if (superType_ != nullptr && ((flags & PropertySearchFlags::SEARCH_IN_BASE) != 0)) { + superType_->CollectSignaturesForSyntheticType(signatures, name, flags, overloadDeclarationCall); } if ((flags & PropertySearchFlags::SEARCH_IN_INTERFACES) != 0) { - for (auto *interface : owner->Interfaces()) { - CollectSignaturesForSyntheticType(interface, signatureSet, name, flags); + for (auto *interface : Interfaces()) { + interface->CollectSignaturesForSyntheticType(signatures, name, flags, overloadDeclarationCall); } } -} -static std::multimap GetSignaturesForSyntheticType(ETSObjectType const *owner, - util::StringView name, - PropertySearchFlags flags) -{ - std::multimap signatureSet; - CollectSignaturesForSyntheticType(owner, &signatureSet, name, flags); - return signatureSet; + return nullptr; } std::vector ETSObjectType::GetAllProperties() const @@ -370,16 +430,42 @@ std::vector ETSObjectType::GetAllProperties() const return allProperties; } +std::vector ETSObjectType::Overloads() const +{ + std::vector methods; + for (const auto &[_, prop] : InstanceMethods()) { + (void)_; + if (prop->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + methods.push_back(prop); + } + } + + for (const auto &[_, prop] : StaticMethods()) { + (void)_; + if (prop->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + methods.push_back(prop); + } + } + + return methods; +} + std::vector ETSObjectType::Methods() const { std::vector methods; for (const auto &[_, prop] : InstanceMethods()) { (void)_; + if (prop->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + continue; + } methods.push_back(prop); } for (const auto &[_, prop] : StaticMethods()) { (void)_; + if (prop->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + continue; + } methods.push_back(prop); } diff --git a/ets2panda/checker/types/ets/etsObjectType.h b/ets2panda/checker/types/ets/etsObjectType.h index 672914ec1c..a56cf8fd0e 100644 --- a/ets2panda/checker/types/ets/etsObjectType.h +++ b/ets2panda/checker/types/ets/etsObjectType.h @@ -342,8 +342,21 @@ public: TypeRelation *relation, GlobalTypesHolder *globalTypes); std::vector Methods() const; std::vector Fields() const; - varbinder::LocalVariable *CreateSyntheticVarFromEverySignature(util::StringView name, + std::vector Overloads() const; + varbinder::LocalVariable *CreateSyntheticVarFromEverySignature(const util::StringView &name, PropertySearchFlags flags) const; + varbinder::LocalVariable *CollectSignaturesForSyntheticType(std::vector &signatures, + const util::StringView &name, PropertySearchFlags flags, + bool &overloadDeclarationCall) const; + void AddSignature(std::vector &signatures, PropertySearchFlags flags, ETSChecker *checker, + varbinder::LocalVariable *found, bool &overloadDeclarationCall) const; + void AddSignatureFromFunction(std::vector &signatures, PropertySearchFlags flags, ETSChecker *checker, + varbinder::LocalVariable *found) const; + void AddSignatureFromOverload(std::vector &signatures, PropertySearchFlags flags, + varbinder::LocalVariable *found, bool &overloadDeclarationCall) const; + void AddSignatureFromConstructor(std::vector &signatures, varbinder::LocalVariable *found) const; + bool ReplaceArgumentInSignature(std::vector &signatures, Signature *sigToInsert, + TypeRelation *relation) const; bool CheckIdenticalFlags(ETSObjectType *other) const; ETSObjectType *CreateETSObjectType(ir::AstNode *declNode, ETSObjectFlags flags); void Iterate(const PropertyTraverser &cb) const; diff --git a/ets2panda/compiler/core/ETSCompilerUnrechable.cpp b/ets2panda/compiler/core/ETSCompilerUnrechable.cpp index 4536b5cebf..77abdb301f 100644 --- a/ets2panda/compiler/core/ETSCompilerUnrechable.cpp +++ b/ets2panda/compiler/core/ETSCompilerUnrechable.cpp @@ -52,6 +52,11 @@ void ETSCompiler::Compile([[maybe_unused]] const ir::MethodDefinition *node) con ES2PANDA_UNREACHABLE(); } +void ETSCompiler::Compile([[maybe_unused]] const ir::OverloadDeclaration *node) const +{ + ES2PANDA_UNREACHABLE(); +} + void ETSCompiler::Compile([[maybe_unused]] const ir::Property *expr) const { ES2PANDA_UNREACHABLE(); diff --git a/ets2panda/compiler/core/ETSemitter.cpp b/ets2panda/compiler/core/ETSemitter.cpp index 376ae87f82..c416ee4805 100644 --- a/ets2panda/compiler/core/ETSemitter.cpp +++ b/ets2panda/compiler/core/ETSemitter.cpp @@ -15,6 +15,7 @@ #include "ETSemitter.h" +#include "annotation.h" #include "compiler/core/ETSGen.h" #include "varbinder/varbinder.h" #include "varbinder/ETSBinder.h" @@ -155,6 +156,10 @@ static pandasm::Function GenScriptFunction(const ir::ScriptFunction *scriptFunc, func.metadata->SetAnnotations(emitter->GenCustomAnnotations(scriptFunc->Annotations(), func.name)); } + if (scriptFunc->IsConstructor()) { + func.metadata->SetAttribute(Signatures::CONSTRUCTOR); + } + return func; } @@ -531,6 +536,13 @@ void ETSEmitter::GenInterfaceRecord(const ir::TSInterfaceDeclaration *interfaceD } } + if (std::any_of(interfaceDecl->Body()->Body().begin(), interfaceDecl->Body()->Body().end(), + [](const ir::AstNode *node) { return node->IsOverloadDeclaration(); })) { + std::vector annotations {}; + annotations.emplace_back(GenAnnotationFunctionOverload(interfaceDecl->Body()->Body())); + interfaceRecord.metadata->AddAnnotations(annotations); + } + if (external) { interfaceRecord.metadata->SetAttribute(Signatures::EXTERNAL); Program()->recordTable.emplace(interfaceRecord.name, std::move(interfaceRecord)); @@ -577,6 +589,11 @@ std::vector ETSEmitter::GenAnnotations(const ir::ClassD annotations.push_back(GenAnnotationDynamicCall(*callNames)); } + if (std::any_of(classDef->Body().begin(), classDef->Body().end(), + [](const ir::AstNode *node) { return node->IsOverloadDeclaration(); })) { + annotations.push_back(GenAnnotationFunctionOverload(classDef->Body())); + } + return annotations; } @@ -949,6 +966,32 @@ pandasm::AnnotationData ETSEmitter::GenAnnotationModule(const ir::ClassDefinitio return moduleAnno; } +pandasm::AnnotationData ETSEmitter::GenAnnotationFunctionOverload(const ArenaVector &body) +{ + GenAnnotationRecord(Signatures::ETS_ANNOTATION_FUNCTION_OVERLOAD); + pandasm::AnnotationData overloadAnno(Signatures::ETS_ANNOTATION_FUNCTION_OVERLOAD); + + for (auto *node : body) { + if (!node->IsOverloadDeclaration()) { + continue; + } + std::vector overloadDeclRecords {}; + + for (auto *overloadedName : node->AsOverloadDeclaration()->OverloadedList()) { + auto *methodDef = overloadedName->Variable()->Declaration()->Node()->AsMethodDefinition(); + overloadDeclRecords.emplace_back(pandasm::ScalarValue::Create( + methodDef->Function()->Scope()->InternalName().Mutf8())); + } + + pandasm::AnnotationElement value( + node->AsOverloadDeclaration()->Id()->Name().Mutf8(), + std::make_unique(pandasm::Value::Type::RECORD, std::move(overloadDeclRecords))); + + overloadAnno.AddElement(std::move(value)); + } + return overloadAnno; +} + pandasm::AnnotationData ETSEmitter::GenAnnotationSignature(const ir::ClassDefinition *classDef) { std::vector parts {}; diff --git a/ets2panda/compiler/core/ETSemitter.h b/ets2panda/compiler/core/ETSemitter.h index db06f5bd5d..084964321b 100644 --- a/ets2panda/compiler/core/ETSemitter.h +++ b/ets2panda/compiler/core/ETSemitter.h @@ -110,6 +110,7 @@ private: void GenClassInheritedFields(const checker::ETSObjectType *baseType, pandasm::Record &classRecord); pandasm::AnnotationData GenAnnotationSignature(const ir::ClassDefinition *classDef); pandasm::AnnotationData GenAnnotationModule(const ir::ClassDefinition *classDef); + pandasm::AnnotationData GenAnnotationFunctionOverload(const ArenaVector &body); pandasm::AnnotationData GenAnnotationEnclosingClass(std::string_view className); pandasm::AnnotationData GenAnnotationEnclosingMethod(const ir::MethodDefinition *methodDef); pandasm::AnnotationData GenAnnotationFunctionalReference(const ir::ClassDefinition *classDef); diff --git a/ets2panda/compiler/core/JSCompilerUnreachable.cpp b/ets2panda/compiler/core/JSCompilerUnreachable.cpp index 8a4b29a9a5..d38cf39039 100644 --- a/ets2panda/compiler/core/JSCompilerUnreachable.cpp +++ b/ets2panda/compiler/core/JSCompilerUnreachable.cpp @@ -48,6 +48,11 @@ void JSCompiler::Compile([[maybe_unused]] const ir::MethodDefinition *node) cons ES2PANDA_UNREACHABLE(); } +void JSCompiler::Compile([[maybe_unused]] const ir::OverloadDeclaration *node) const +{ + ES2PANDA_UNREACHABLE(); +} + void JSCompiler::Compile([[maybe_unused]] const ir::Property *expr) const { ES2PANDA_UNREACHABLE(); diff --git a/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp b/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp index bf69507850..2c0f2d3203 100644 --- a/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp +++ b/ets2panda/compiler/lowering/ets/defaultParametersInConstructorLowering.cpp @@ -181,7 +181,7 @@ static void CreateFunctionOverload(ir::MethodDefinition *method, ArenaVector( allocator, method->Kind(), ident, funcExpression, method->Modifiers(), allocator, false); - overloadMethod->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD); + overloadMethod->Function()->AddFlag(ir::ScriptFunctionFlags::OVERLOAD | ir::ScriptFunctionFlags::SYNTHETIC); overloadMethod->SetRange(funcExpression->Range()); if (!method->IsDeclare() && method->Parent()->IsTSInterfaceBody()) { diff --git a/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp b/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp index 2833087baa..753e708f12 100644 --- a/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp +++ b/ets2panda/compiler/lowering/ets/interfaceObjectLiteralLowering.cpp @@ -126,6 +126,10 @@ static void FillClassBody(public_lib::Context *ctx, ArenaVector * checker::ETSObjectType *currentType = nullptr) { for (auto *it : ifaceBody) { + if (it->IsOverloadDeclaration()) { + continue; + } + ES2PANDA_ASSERT(it->IsMethodDefinition()); auto *ifaceMethod = it->AsMethodDefinition(); @@ -375,6 +379,9 @@ static void HandleInterfaceLowering(public_lib::Context *ctx, ir::ObjectExpressi static bool CheckInterfaceShouldGenerateAnonClass(ir::TSInterfaceDeclaration *interfaceDecl) { for (auto it : interfaceDecl->Body()->Body()) { + if (it->IsOverloadDeclaration()) { + continue; + } ES2PANDA_ASSERT(it->IsMethodDefinition()); auto methodDef = it->AsMethodDefinition(); if (!methodDef->Function()->IsGetter() && !methodDef->Function()->IsSetter()) { diff --git a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp index 0c4e4caf52..befb732fa6 100644 --- a/ets2panda/compiler/lowering/ets/lambdaLowering.cpp +++ b/ets2panda/compiler/lowering/ets/lambdaLowering.cpp @@ -1223,6 +1223,17 @@ static bool IsValidFunctionDeclVar(const varbinder::Variable *const var) !var->TsType()->HasTypeFlag(checker::TypeFlag::GETTER_SETTER); } +static bool IsOverloadedName(ir::Expression *const expr) +{ + if ((!expr->IsIdentifier() && !expr->IsMemberExpression()) || !expr->Parent()->IsOverloadDeclaration()) { + return false; + } + + auto overloadedList = expr->Parent()->AsOverloadDeclaration()->OverloadedList(); + return std::any_of(overloadedList.begin(), overloadedList.end(), + [&expr](const ir::Expression *overloadedName) { return overloadedName == expr; }); +} + static ir::AstNode *BuildLambdaClassWhenNeeded(public_lib::Context *ctx, ir::AstNode *node) { if (node->IsArrowFunctionExpression()) { @@ -1236,7 +1247,7 @@ static ir::AstNode *BuildLambdaClassWhenNeeded(public_lib::Context *ctx, ir::Ast // so it is correct to pass ETS extension here to isReference() if (id->IsReference(ScriptExtension::ETS) && id->TsType() != nullptr && id->TsType()->IsETSFunctionType() && !IsInCalleePosition(id) && !IsEnumFunctionCall(id) && IsValidFunctionDeclVar(var) && - !id->Variable()->HasFlag(varbinder::VariableFlags::DYNAMIC)) { + !id->Variable()->HasFlag(varbinder::VariableFlags::DYNAMIC) && !IsOverloadedName(id)) { return ConvertFunctionReference(ctx, id); } } @@ -1250,7 +1261,7 @@ static ir::AstNode *BuildLambdaClassWhenNeeded(public_lib::Context *ctx, ir::Ast checker::PropertySearchFlags::SEARCH_INSTANCE_METHOD | checker::PropertySearchFlags::SEARCH_STATIC_METHOD | checker::PropertySearchFlags::SEARCH_IN_BASE | checker::PropertySearchFlags::DISALLOW_SYNTHETIC_METHOD_CREATION); - if (IsValidFunctionDeclVar(var) && !IsInCalleePosition(mexpr)) { + if (IsValidFunctionDeclVar(var) && !IsInCalleePosition(mexpr) && !IsOverloadedName(mexpr)) { return ConvertFunctionReference(ctx, mexpr); } } diff --git a/ets2panda/compiler/lowering/ets/overloadMappingLowering.cpp b/ets2panda/compiler/lowering/ets/overloadMappingLowering.cpp new file mode 100644 index 0000000000..a72a5c6517 --- /dev/null +++ b/ets2panda/compiler/lowering/ets/overloadMappingLowering.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2025 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 "overloadMappingLowering.h" +#include "checker/ETSchecker.h" +#include "compiler/lowering/util.h" + +namespace ark::es2panda::compiler { + +using AstNodePtr = ir::AstNode *; + +std::string_view OverloadMappingLowering::Name() const +{ + return "OverloadMappingLowering"; +} + +static ir::CallExpression *MethodMapping(public_lib::Context *ctx, ir::CallExpression *callExpression) +{ + auto *checker = ctx->GetChecker()->AsETSChecker(); + auto *allocator = ctx->Allocator(); + + auto *signature = callExpression->Signature(); + ES2PANDA_ASSERT(signature->OwnerVar()->Declaration()->Node()->IsMethodDefinition()); + auto *methodDef = signature->OwnerVar()->Declaration()->Node()->AsMethodDefinition(); + + ir::AstNode *callee = callExpression->Callee(); + while (callee->IsMemberExpression()) { + callee = callee->AsMemberExpression()->Property(); + } + auto *ident = callee->AsIdentifier(); + ident->SetName(methodDef->Id()->Name()); + + varbinder::LocalVariable *syntheticVariable = allocator->New( + varbinder::VariableFlags::SYNTHETIC | varbinder::VariableFlags::METHOD); + ident->SetVariable(syntheticVariable); + checker::ETSFunctionType *funcType = + checker->CreateETSMethodType(methodDef->Id()->Name(), {{}, allocator->Adapter()}); + funcType->AddCallSignature(signature); + syntheticVariable->SetTsType(funcType); + + return callExpression; +} + +static bool IsOverloadDeclarationCall(ir::Expression *expr) +{ + while (expr->IsMemberExpression()) { + expr = expr->AsMemberExpression()->Property(); + } + + if (expr->IsIdentifier() && expr->AsIdentifier()->Variable() != nullptr) { + return expr->AsIdentifier()->Variable()->HasFlag(varbinder::VariableFlags::OVERLOAD); + } + return false; +} + +bool OverloadMappingLowering::PerformForModule(public_lib::Context *ctx, parser::Program *program) +{ + program->Ast()->TransformChildrenRecursively( + // CC-OFFNXT(G.FMT.14-CPP) project code style + [ctx](ir::AstNode *const node) -> AstNodePtr { + if (node->IsCallExpression() && IsOverloadDeclarationCall(node->AsCallExpression()->Callee())) { + return MethodMapping(ctx, node->AsCallExpression()); + } + return node; + }, + Name()); + + return true; +} + +} // namespace ark::es2panda::compiler diff --git a/ets2panda/compiler/lowering/ets/overloadMappingLowering.h b/ets2panda/compiler/lowering/ets/overloadMappingLowering.h new file mode 100644 index 0000000000..2efcadbdc4 --- /dev/null +++ b/ets2panda/compiler/lowering/ets/overloadMappingLowering.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2025 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_COMPILER_LOWERING_OVERLOAD_MAPPING_LOWERING_H +#define ES2PANDA_COMPILER_LOWERING_OVERLOAD_MAPPING_LOWERING_H + +#include "compiler/lowering/phase.h" + +namespace ark::es2panda::compiler { + +class OverloadMappingLowering : public PhaseForDeclarations { +public: + std::string_view Name() const override; + bool PerformForModule(public_lib::Context *ctx, parser::Program *program) override; +}; + +} // namespace ark::es2panda::compiler + +#endif diff --git a/ets2panda/compiler/lowering/ets/restTupleLowering.cpp b/ets2panda/compiler/lowering/ets/restTupleLowering.cpp index 9d388f9afb..c01e578292 100644 --- a/ets2panda/compiler/lowering/ets/restTupleLowering.cpp +++ b/ets2panda/compiler/lowering/ets/restTupleLowering.cpp @@ -261,7 +261,7 @@ ir::ScriptFunction *CreateNewScriptFunction(public_lib::Context *ctx, ir::Script auto *newScriptFunc = ctx->AllocNode( allocator, ir::ScriptFunction::ScriptFunctionData { body, ir::FunctionSignature(newParamDeclaration, std::move(newParams), newReturnTypeAnno), - scriptFunc->Flags()}); + scriptFunc->Flags() | ir::ScriptFunctionFlags::SYNTHETIC}); newScriptFunc->AddModifier(scriptFunc->AsScriptFunction()->Modifiers()); ArenaVector annotationUsages {allocator->Adapter()}; diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp b/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp index 1560a75375..4c4576fa1b 100644 --- a/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp +++ b/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.cpp @@ -48,6 +48,11 @@ void GlobalDeclTransformer::VisitExpressionStatement(ir::ExpressionStatement *ex result_.immediateInit.emplace_back(exprStmt); } +void GlobalDeclTransformer::VisitOverloadDeclaration(ir::OverloadDeclaration *overloadDeclaration) +{ + result_.classProperties.emplace_back(overloadDeclaration); +} + void GlobalDeclTransformer::VisitFunctionDeclaration(ir::FunctionDeclaration *funcDecl) { auto *funcExpr = util::NodeAllocator::ForceSetParent(allocator_, funcDecl->Function()); diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.h b/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.h index eada14a27c..e8631b95a2 100644 --- a/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.h +++ b/ets2panda/compiler/lowering/ets/topLevelStmts/globalDeclTransformer.h @@ -79,6 +79,7 @@ public: */ ResultT TransformStatements(const ArenaVector &stmts); + void VisitOverloadDeclaration(ir::OverloadDeclaration *overloadDeclaration) override; void VisitFunctionDeclaration(ir::FunctionDeclaration *funcDecl) override; void VisitVariableDeclaration(ir::VariableDeclaration *varDecl) override; void VisitClassStaticBlock(ir::ClassStaticBlock *classStaticBlock) override; diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp index f173d3fa47..54dfc6d2f4 100644 --- a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp +++ b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.cpp @@ -176,6 +176,11 @@ void ImportExportDecls::VisitFunctionDeclaration(ir::FunctionDeclaration *funcDe fieldMap_.emplace(funcDecl->Function()->Id()->Name(), funcDecl->Function()); } +void ImportExportDecls::VisitOverloadDeclaration(ir::OverloadDeclaration *overloadDeclaration) +{ + fieldMap_.emplace(overloadDeclaration->Id()->Name(), overloadDeclaration); +} + void ImportExportDecls::VisitVariableDeclaration(ir::VariableDeclaration *varDecl) { for (const auto &decl : varDecl->Declarators()) { diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h index c6c8f76314..27b17db341 100644 --- a/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h +++ b/ets2panda/compiler/lowering/ets/topLevelStmts/importExportDecls.h @@ -74,6 +74,7 @@ public: void PreMergeNamespaces(parser::Program *program); private: + void VisitOverloadDeclaration(ir::OverloadDeclaration *overloadDeclaration) override; void VisitFunctionDeclaration(ir::FunctionDeclaration *funcDecl) override; void VisitVariableDeclaration(ir::VariableDeclaration *varDecl) override; void VisitExportNamedDeclaration(ir::ExportNamedDeclaration *exportDecl) override; diff --git a/ets2panda/compiler/lowering/phase.cpp b/ets2panda/compiler/lowering/phase.cpp index 18eefa5f2d..800aef488d 100644 --- a/ets2panda/compiler/lowering/phase.cpp +++ b/ets2panda/compiler/lowering/phase.cpp @@ -54,6 +54,7 @@ #include "compiler/lowering/ets/opAssignment.h" #include "compiler/lowering/ets/optionalArgumentsLowering.h" #include "compiler/lowering/ets/optionalLowering.h" +#include "compiler/lowering/ets/overloadMappingLowering.h" #include "compiler/lowering/ets/packageImplicitImport.h" #include "compiler/lowering/ets/partialExportClassGen.h" #include "compiler/lowering/ets/primitiveConversionPhase.h" @@ -135,6 +136,7 @@ std::vector GetETSPhaseList() new AnnotationCopyPostLowering, new AsyncMethodLowering, new DeclareOverloadLowering, + new OverloadMappingLowering, new EnumPostCheckLoweringPhase, new SpreadConstructionPhase, new RestArgsLowering, diff --git a/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.cpp b/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.cpp index 49e83d88f1..c5a51475ae 100644 --- a/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.cpp +++ b/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.cpp @@ -414,7 +414,19 @@ void ScopesInitPhase::IterateNoTParams(ir::ClassDefinition *classDef) CallNode(classDef->Annotations()); CallNode(classDef->Implements()); CallNode(classDef->Ctor()); - CallNode(classDef->Body()); + + for (auto property : classDef->Body()) { + if (property->IsOverloadDeclaration()) { + continue; + } + CallNode(property); + } + + for (auto property : classDef->Body()) { + if (property->IsOverloadDeclaration()) { + CallNode(property); + } + } } void ScopesInitPhase::LogDiagnostic(const diagnostic::DiagnosticKind &kind, const util::DiagnosticMessageParams ¶ms, @@ -1036,6 +1048,96 @@ void InitScopesPhaseETS::MaybeAddOverload(ir::MethodDefinition *method, ir::Iden } } +void InitScopesPhaseETS::VisitOverloadDeclaration(ir::OverloadDeclaration *overload) +{ + auto *curScope = VarBinder()->GetScope(); + const auto overloadName = overload->Id(); + auto res = + curScope->Find(overloadName->Name(), overload->IsStatic() ? varbinder::ResolveBindingOptions::ALL_STATIC + : varbinder::ResolveBindingOptions::ALL_NON_STATIC); + if (res.variable != nullptr) { + VarBinder()->ThrowRedeclaration(overloadName->Start(), res.name, varbinder::DeclType::METHOD); + } + + auto result = curScope->FindLocal(overloadName->Name(), varbinder::ResolveBindingOptions::ALL_DECLARATION); + if (result != nullptr) { + VarBinder()->ThrowLocalRedeclaration(overloadName->Start(), result->Name()); + } + + Iterate(overload); + DeclareClassOverload(overload); +} + +varbinder::LocalScope *InitScopesPhaseETS::OverloadTargetScope(ir::OverloadDeclaration *overloadDef, + varbinder::ClassScope *clsScope) +{ + varbinder::LocalScope *targetScope {}; + if (overloadDef->IsConstructorOverloadDeclaration()) { + targetScope = clsScope->StaticMethodScope(); + + auto *found = targetScope->FindLocal(Signatures::CONSTRUCTOR_NAME, varbinder::ResolveBindingOptions::BINDINGS); + if (found == nullptr || + (!overloadDef->OverloadedList().empty() && overloadDef->OverloadedList().front()->IsIdentifier() && + overloadDef->OverloadedList().front()->AsIdentifier()->Name().Is(Signatures::CONSTRUCTOR_NAME))) { + return targetScope; + } + ir::Identifier *anonyConstructor = Allocator()->New(Signatures::CONSTRUCTOR_NAME, Allocator()); + overloadDef->PushFront(anonyConstructor); + anonyConstructor->SetParent(overloadDef); + } else { + targetScope = overloadDef->IsStatic() ? clsScope->StaticMethodScope() : clsScope->InstanceMethodScope(); + } + + return targetScope; +} + +void InitScopesPhaseETS::DeclareClassOverload(ir::OverloadDeclaration *overloadDef) +{ + ES2PANDA_ASSERT(VarBinder()->GetScope()->IsClassScope()); + + const auto overloadName = overloadDef->Id(); + auto *const clsScope = VarBinder()->GetScope()->AsClassScope(); + auto options = + overloadDef->IsStatic() + ? varbinder::ResolveBindingOptions::STATIC_VARIABLES | varbinder::ResolveBindingOptions::STATIC_DECLARATION + : varbinder::ResolveBindingOptions::VARIABLES | varbinder::ResolveBindingOptions::DECLARATION; + auto variable = clsScope->FindLocal(overloadName->Name(), options); + if (variable != nullptr) { + VarBinder()->ThrowRedeclaration(overloadName->Start(), overloadName->Name(), variable->Declaration()->Type()); + } + + varbinder::LocalScope *targetScope = OverloadTargetScope(overloadDef, clsScope); + for (auto *methodName : overloadDef->OverloadedList()) { + if (!methodName->IsIdentifier()) { + continue; + } + + auto *found = + targetScope->FindLocal(methodName->AsIdentifier()->Name(), varbinder::ResolveBindingOptions::BINDINGS); + + if (found == nullptr) { + continue; + } + + if (!found->Declaration()->Node()->IsMethodDefinition()) { + VarBinder()->ThrowError(methodName->Start(), diagnostic::OVERLOADED_NAME_MUST_FUNCTION); + continue; + } + + methodName->SetVariable(found); + } + + auto classCtx = varbinder::LexicalScope::Enter(VarBinder(), targetScope); + auto var = std::get<1>(VarBinder()->NewVarDecl(overloadName->Start(), Allocator(), + overloadName->Name(), overloadDef)); + var->SetScope(clsScope); + if (targetScope->HasFlag(varbinder::ScopeFlags::STATIC)) { + var->AddFlag(varbinder::VariableFlags::STATIC); + } + var->AddFlag(varbinder::VariableFlags::OVERLOAD); + overloadName->SetVariable(var); +} + void InitScopesPhaseETS::VisitETSReExportDeclaration(ir::ETSReExportDeclaration *reExport) { if (!reExport->GetETSImportDeclarations()->IsValid()) { @@ -1270,7 +1372,18 @@ void InitScopesPhaseETS::VisitClassDefinition(ir::ClassDefinition *classDef) void InitScopesPhaseETS::VisitTSInterfaceBody(ir::TSInterfaceBody *interfBody) { - Iterate(interfBody); + for (auto property : interfBody->Body()) { + if (property->IsOverloadDeclaration()) { + continue; + } + CallNode(property); + } + + for (auto property : interfBody->Body()) { + if (property->IsOverloadDeclaration()) { + CallNode(property); + } + } FilterInterfaceOverloads(interfBody->Body()); } diff --git a/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.h b/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.h index e3b5d7e556..75f98406d4 100644 --- a/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.h +++ b/ets2panda/compiler/lowering/scopesInit/scopesInitPhase.h @@ -344,6 +344,8 @@ private: void DeclareClassMethod(ir::MethodDefinition *method); void MaybeAddOverload(ir::MethodDefinition *method, ir::Identifier *methodName, varbinder::Variable *found, varbinder::ClassScope *clsScope, varbinder::LocalScope *targetScope); + void DeclareClassOverload(ir::OverloadDeclaration *overloadDef); + varbinder::LocalScope *OverloadTargetScope(ir::OverloadDeclaration *overloadDef, varbinder::ClassScope *clsScope); void VisitClassStaticBlock(ir::ClassStaticBlock *staticBlock) override; void VisitBlockExpression(ir::BlockExpression *blockExpr) override; @@ -354,6 +356,7 @@ private: void VisitETSParameterExpression(ir::ETSParameterExpression *paramExpr) override; void VisitETSImportDeclaration(ir::ETSImportDeclaration *importDecl) override; void VisitTSEnumMember(ir::TSEnumMember *enumMember) override; + void VisitOverloadDeclaration(ir::OverloadDeclaration *overload) override; void VisitMethodDefinition(ir::MethodDefinition *method) override; void VisitETSFunctionType(ir::ETSFunctionType *funcType) override; void VisitETSNewClassInstanceExpression(ir::ETSNewClassInstanceExpression *newClassExpr) override; diff --git a/ets2panda/compiler/scripts/signatures.yaml b/ets2panda/compiler/scripts/signatures.yaml index 5f96465346..d44d0d0c16 100644 --- a/ets2panda/compiler/scripts/signatures.yaml +++ b/ets2panda/compiler/scripts/signatures.yaml @@ -109,6 +109,9 @@ defines: - name: ets/annotation/FunctionalReference ref: ETS_ANNOTATION_FUNCTIONAL_REFERENCE comment: Ets record + - name: ets/annotation/FunctionOverload + ref: ETS_ANNOTATION_FUNCTION_OVERLOAD + comment: Ets record - name: ets/coroutine/Async ref: ETS_COROUTINE_ASYNC - name: ets/annotation/DynamicCall @@ -248,6 +251,10 @@ defines: ref: UNUSED_ETSGLOBAL_MAIN - name: "initialize" ref: CLASS_INITIALIZE_METHOD + - name: 'constructor' + ref: CONSTRUCTOR_NAME + - name: 'gensym%%_constructor_overload_declaration' + ref: CONSTRUCTOR_OVERLOAD_DEFINITION_NAME packages: - name: 'std.core' diff --git a/ets2panda/ir/astNode.cpp b/ets2panda/ir/astNode.cpp index 696841c7b6..8114961153 100644 --- a/ets2panda/ir/astNode.cpp +++ b/ets2panda/ir/astNode.cpp @@ -88,13 +88,13 @@ void AstNode::ClearScope() noexcept ir::ClassElement *AstNode::AsClassElement() { - ES2PANDA_ASSERT(IsMethodDefinition() || IsClassProperty() || IsClassStaticBlock()); + ES2PANDA_ASSERT(IsMethodDefinition() || IsClassProperty() || IsClassStaticBlock() || IsOverloadDeclaration()); return reinterpret_cast(this); } const ir::ClassElement *AstNode::AsClassElement() const { - ES2PANDA_ASSERT(IsMethodDefinition() || IsClassProperty() || IsClassStaticBlock()); + ES2PANDA_ASSERT(IsMethodDefinition() || IsClassProperty() || IsClassStaticBlock() || IsOverloadDeclaration()); return reinterpret_cast(this); } @@ -312,4 +312,13 @@ bool AstNode::HistoryInitialized() const return history_ != nullptr; } +void AstNode::CleanCheckInformation() +{ + if (IsTyped()) { + this->AsTyped()->SetTsType(nullptr); + this->AsTyped()->SetPreferredType(nullptr); + } + Iterate([&](auto *childNode) { childNode->CleanCheckInformation(); }); +} + } // namespace ark::es2panda::ir diff --git a/ets2panda/ir/astNode.h b/ets2panda/ir/astNode.h index 3f5a8edd9a..751d44cefc 100644 --- a/ets2panda/ir/astNode.h +++ b/ets2panda/ir/astNode.h @@ -690,6 +690,8 @@ public: AstNode *GetOrCreateHistoryNode() const; + virtual void CleanCheckInformation(); + protected: AstNode(AstNode const &other); diff --git a/ets2panda/ir/astNodeFlags.h b/ets2panda/ir/astNodeFlags.h index ea8783348a..86f9c39c08 100644 --- a/ets2panda/ir/astNodeFlags.h +++ b/ets2panda/ir/astNodeFlags.h @@ -81,7 +81,18 @@ enum class ModifierFlags : uint32_t { EXPORTED = EXPORT | DEFAULT_EXPORT | EXPORT_TYPE }; -enum class PrivateFieldKind { FIELD, METHOD, GET, SET, STATIC_FIELD, STATIC_METHOD, STATIC_GET, STATIC_SET }; +enum class PrivateFieldKind { + FIELD, + METHOD, + GET, + SET, + STATIC_FIELD, + STATIC_METHOD, + STATIC_GET, + STATIC_SET, + OVERLOAD, + STATIC_OVERLOAD +}; enum class ScriptFunctionFlags : uint32_t { NONE = 0U, @@ -109,6 +120,7 @@ enum class ScriptFunctionFlags : uint32_t { HAS_THROW = 1U << 21U, IN_RECORD = 1U << 22U, TRAILING_LAMBDA = 1U << 23U, + SYNTHETIC = 1U << 24U, }; enum class TSOperatorType { READONLY, KEYOF, UNIQUE }; diff --git a/ets2panda/ir/astNodeMapping.h b/ets2panda/ir/astNodeMapping.h index 06ece5eff0..34908d0e7c 100644 --- a/ets2panda/ir/astNodeMapping.h +++ b/ets2panda/ir/astNodeMapping.h @@ -73,6 +73,7 @@ _(UNDEFINED_LITERAL, UndefinedLiteral) \ _(NUMBER_LITERAL, NumberLiteral) \ _(OMITTED_EXPRESSION, OmittedExpression) \ + _(OVERLOAD_DECLARATION, OverloadDeclaration) \ _(PREFIX_ASSERTION_EXPRESSION, PrefixAssertionExpression) \ _(PROPERTY, Property) \ _(REGEXP_LITERAL, RegExpLiteral) \ diff --git a/ets2panda/ir/base/methodDefinition.cpp b/ets2panda/ir/base/methodDefinition.cpp index 6f705a2f97..c226b741b3 100644 --- a/ets2panda/ir/base/methodDefinition.cpp +++ b/ets2panda/ir/base/methodDefinition.cpp @@ -345,6 +345,11 @@ void MethodDefinition::Dump(ir::SrcDumper *dumper) const } DumpPrefix(dumper); + if (IsConstructor() && + !(Key()->IsIdentifier() && Key()->AsIdentifier()->Name().Is(compiler::Signatures::CONSTRUCTOR_NAME))) { + dumper->Add(std::string(compiler::Signatures::CONSTRUCTOR_NAME) + " "); + } + auto key = Key(); if (key != nullptr) { key->Dump(dumper); diff --git a/ets2panda/ir/base/overloadDeclaration.cpp b/ets2panda/ir/base/overloadDeclaration.cpp new file mode 100644 index 0000000000..7af8f592ff --- /dev/null +++ b/ets2panda/ir/base/overloadDeclaration.cpp @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2025 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 "overloadDeclaration.h" +#include "checker/ETSchecker.h" +#include "compiler/lowering/util.h" + +namespace ark::es2panda::ir { +PrivateFieldKind OverloadDeclaration::ToPrivateFieldKind(bool const isStatic) const +{ + return isStatic ? PrivateFieldKind::STATIC_OVERLOAD : PrivateFieldKind::OVERLOAD; +} + +void OverloadDeclaration::ResolveReferences(const NodeTraverser &cb) const +{ + cb(key_); + + for (auto *it : VectorIterationGuard(overloadedList_)) { + cb(it); + } +} + +void OverloadDeclaration::TransformChildren(const NodeTransformer &cb, std::string_view const transformationName) +{ + cb(key_); + for (auto *&it : VectorIterationGuard(overloadedList_)) { + if (auto *transformedNode = cb(it); it != transformedNode) { + it->SetTransformedNode(transformationName, transformedNode); + it = transformedNode->AsIdentifier(); + } + } +} + +void OverloadDeclaration::Iterate(const NodeTraverser &cb) const +{ + cb(key_); + for (auto *it : VectorIterationGuard(overloadedList_)) { + cb(it); + } +} + +void OverloadDeclaration::Dump(ir::AstDumper *dumper) const +{ + dumper->Add({{"type", "OverloadDeclaration"}, + {"key", key_}, + {"optional", AstDumper::Optional(AstDumper::ModifierToString(flags_))}, + {"static", IsStatic()}, + {"overloadedList", overloadedList_}}); +} + +void OverloadDeclaration::DumpModifier(ir::SrcDumper *dumper) const +{ + if (compiler::HasGlobalClassParent(this) && !dumper->IsDeclgen()) { + if (IsExported()) { + dumper->Add("export "); + } + } + + if (Parent() != nullptr && Parent()->IsClassDefinition() && !Parent()->AsClassDefinition()->IsLocal() && + !compiler::HasGlobalClassParent(this)) { + 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 (IsAsync()) { + dumper->Add("async "); + } +} + +void OverloadDeclaration::Dump(ir::SrcDumper *dumper) const +{ + DumpModifier(dumper); + dumper->Add("overload "); + dumper->Add(IsConstructor() ? "constructor " : key_->AsIdentifier()->Name().Mutf8()); + dumper->Add("{"); + for (size_t i = 0; i < overloadedList_.size(); i++) { + if (i != 0) { + dumper->Add(", "); + } + overloadedList_[i]->Dump(dumper); + } + dumper->Add("};"); +} + +void OverloadDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {} + +checker::Type *OverloadDeclaration::Check([[maybe_unused]] checker::TSChecker *checker) +{ + return nullptr; +} + +checker::VerifiedType OverloadDeclaration::Check([[maybe_unused]] checker::ETSChecker *checker) +{ + return {this, checker->GetAnalyzer()->Check(this)}; +} + +OverloadDeclaration *OverloadDeclaration::Construct(ArenaAllocator *allocator) +{ + return allocator->New(nullptr, ModifierFlags::NONE, allocator); +} + +void OverloadDeclaration::CopyTo(AstNode *other) const +{ + auto otherImpl = other->AsOverloadDeclaration(); + + otherImpl->overloadFlags_ = overloadFlags_; + otherImpl->overloadedList_ = overloadedList_; + ClassElement::CopyTo(other); +} + +} // namespace ark::es2panda::ir \ No newline at end of file diff --git a/ets2panda/ir/base/overloadDeclaration.h b/ets2panda/ir/base/overloadDeclaration.h new file mode 100644 index 0000000000..667c653f8d --- /dev/null +++ b/ets2panda/ir/base/overloadDeclaration.h @@ -0,0 +1,140 @@ +/** + * Copyright (c) 2025 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_OVERLOAD_DEFINITION_H +#define ES2PANDA_IR_OVERLOAD_DEFINITION_H + +#include "classDefinition.h" +#include "ir/typeNode.h" +#include "methodDefinition.h" + +namespace ark::es2panda::ir { + +using ENUMBITOPS_OPERATORS; + +enum class OverloadDeclFlags : std::uint8_t { + NONE = 0U, + FUNCTION = 1U << 0U, // Function Overload Declaration + CLASS_METHOD = 1U << 1U, // Class Method Overload Declaration + INTERFACE_METHOD = 1U << 2U, // Interface Method Overload Declaration + // CONSTURCTOR = 1U << 3U, // Constructor Overload Declarations +}; +} // namespace ark::es2panda::ir + +namespace enumbitops { + +template <> +struct IsAllowedType : std::true_type { +}; + +} // namespace enumbitops + +namespace ark::es2panda::ir { +class OverloadDeclaration : public ClassElement { +public: + OverloadDeclaration() = delete; + ~OverloadDeclaration() override = default; + + NO_COPY_SEMANTIC(OverloadDeclaration); + NO_MOVE_SEMANTIC(OverloadDeclaration); + + explicit OverloadDeclaration(Expression *const key, ModifierFlags const modifiers, ArenaAllocator *const allocator) + : ClassElement(AstNodeType::OVERLOAD_DECLARATION, key, nullptr, modifiers, allocator, false), + overloadedList_(allocator->Adapter()), + overloadFlags_(OverloadDeclFlags::NONE) + { + InitHistory(); + } + + OverloadDeclFlags Flag() const + { + return GetHistoryNodeAs()->overloadFlags_; + } + + [[nodiscard]] ArenaVector &OverloadedList() noexcept + { + return GetOrCreateHistoryNodeAs()->overloadedList_; + } + + void SetOverloadedList(ArenaVector overloadedList) + { + auto newNode = GetOrCreateHistoryNodeAs(); + newNode->overloadedList_ = std::move(overloadedList); + } + + void PushFront(Identifier *const overloadedExpression) + { + auto newNode = GetOrCreateHistoryNodeAs(); + newNode->overloadedList_.insert(overloadedList_.begin(), overloadedExpression); + } + + void AddOverloadDeclFlag(OverloadDeclFlags overloadFlag) + { + auto newNode = GetOrCreateHistoryNodeAs(); + newNode->overloadFlags_ |= overloadFlag; + } + + [[nodiscard]] bool HasOverloadDeclFlag(OverloadDeclFlags overloadFlag) const + { + return (Flag() & overloadFlag) != 0; + } + + [[nodiscard]] bool IsConstructorOverloadDeclaration() + { + return IsConstructor(); + } + + [[nodiscard]] bool IsFunctionOverloadDeclaration() + { + return (Flag() & OverloadDeclFlags::FUNCTION) != 0; + } + + [[nodiscard]] bool IsClassMethodOverloadDeclaration() + { + return (Flag() & OverloadDeclFlags::CLASS_METHOD) != 0; + } + + [[nodiscard]] bool IsInterfaceMethodOverloadDeclaration() + { + return (Flag() & OverloadDeclFlags::INTERFACE_METHOD) != 0; + } + + void ResolveReferences(const NodeTraverser &cb) const; + + PrivateFieldKind ToPrivateFieldKind(bool isStatic) const override; + void TransformChildren(const NodeTransformer &cb, std::string_view transformationName) override; + void Iterate(const NodeTraverser &cb) const override; + void Dump(ir::AstDumper *dumper) const override; + void Dump(ir::SrcDumper *dumper) const override; + void DumpModifier(ir::SrcDumper *dumper) const; + void Compile([[maybe_unused]] compiler::PandaGen *pg) const override; + checker::Type *Check([[maybe_unused]] checker::TSChecker *checker) override; + checker::VerifiedType Check([[maybe_unused]] checker::ETSChecker *checker) override; + void Accept(ASTVisitorT *v) override + { + v->Accept(this); + } + +protected: + OverloadDeclaration *Construct(ArenaAllocator *allocator) override; + void CopyTo(AstNode *other) const override; + +private: + ArenaVector overloadedList_; + OverloadDeclFlags overloadFlags_; +}; +} // namespace ark::es2panda::ir + +#endif diff --git a/ets2panda/ir/base/scriptFunction.h b/ets2panda/ir/base/scriptFunction.h index 56ba72e368..f8d619152e 100644 --- a/ets2panda/ir/base/scriptFunction.h +++ b/ets2panda/ir/base/scriptFunction.h @@ -257,6 +257,11 @@ public: return (Flags() & ir::ScriptFunctionFlags::TRAILING_LAMBDA) != 0; } + [[nodiscard]] bool IsSynthetic() const noexcept + { + return (Flags() & ir::ScriptFunctionFlags::SYNTHETIC) != 0; + } + [[nodiscard]] bool IsDynamic() const noexcept { return Language().IsDynamic(); diff --git a/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp b/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp index db8c7b5eea..638627789f 100644 --- a/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp +++ b/ets2panda/ir/ets/etsNewArrayInstanceExpression.cpp @@ -109,6 +109,15 @@ void ETSNewArrayInstanceExpression::ClearPreferredType() SetTsType(nullptr); } +void ETSNewArrayInstanceExpression::CleanCheckInformation() +{ + SetPreferredType(nullptr); + SetTsType(nullptr); + if (dimension_ != nullptr) { + dimension_->CleanCheckInformation(); + } +} + void ETSNewArrayInstanceExpression::SetPreferredTypeBasedOnFuncParam(checker::ETSChecker *checker, checker::Type *param, checker::TypeRelationFlag flags) { diff --git a/ets2panda/ir/ets/etsNewArrayInstanceExpression.h b/ets2panda/ir/ets/etsNewArrayInstanceExpression.h index b1b4885340..002a1cb1a6 100644 --- a/ets2panda/ir/ets/etsNewArrayInstanceExpression.h +++ b/ets2panda/ir/ets/etsNewArrayInstanceExpression.h @@ -113,6 +113,7 @@ public: } void ClearPreferredType(); + void CleanCheckInformation() override; private: ir::TypeNode *typeReference_; diff --git a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp index d5cd0530e8..f18b4e7a3a 100644 --- a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp +++ b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.cpp @@ -89,6 +89,15 @@ void ETSNewMultiDimArrayInstanceExpression::ClearPreferredType() SetTsType(nullptr); } +void ETSNewMultiDimArrayInstanceExpression::CleanCheckInformation() +{ + SetPreferredType(nullptr); + SetTsType(nullptr); + for (auto *dim : dimensions_) { + dim->CleanCheckInformation(); + } +} + ETSNewMultiDimArrayInstanceExpression::ETSNewMultiDimArrayInstanceExpression( ETSNewMultiDimArrayInstanceExpression const &other, ArenaAllocator *const allocator) : Expression(static_cast(other)), diff --git a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h index 31aab67ffa..20d8be5d48 100644 --- a/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h +++ b/ets2panda/ir/ets/etsNewMultiDimArrayInstanceExpression.h @@ -110,6 +110,7 @@ public: } void ClearPreferredType(); + void CleanCheckInformation() override; private: ir::TypeNode *typeReference_; diff --git a/ets2panda/ir/ets/etsUnionType.cpp b/ets2panda/ir/ets/etsUnionType.cpp index de035bcd61..19f2311988 100644 --- a/ets2panda/ir/ets/etsUnionType.cpp +++ b/ets2panda/ir/ets/etsUnionType.cpp @@ -49,6 +49,7 @@ void ETSUnionType::Dump(ir::AstDumper *dumper) const void ETSUnionType::Dump(ir::SrcDumper *dumper) const { + dumper->Add("("); for (auto *anno : Annotations()) { anno->Dump(dumper); } @@ -58,6 +59,7 @@ void ETSUnionType::Dump(ir::SrcDumper *dumper) const dumper->Add(" | "); } } + dumper->Add(")"); } void ETSUnionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {} diff --git a/ets2panda/ir/expressions/arrayExpression.cpp b/ets2panda/ir/expressions/arrayExpression.cpp index 418e936818..3e0a753d33 100644 --- a/ets2panda/ir/expressions/arrayExpression.cpp +++ b/ets2panda/ir/expressions/arrayExpression.cpp @@ -363,6 +363,16 @@ void ArrayExpression::ClearPreferredType() } } +void ArrayExpression::CleanCheckInformation() +{ + SetPreferredType(nullptr); + SetTsType(nullptr); + for (auto *element : elements_) { + element->SetAstNodeFlags(ir::AstNodeFlags::NO_OPTS); + element->CleanCheckInformation(); + } +} + bool ArrayExpression::TrySetPreferredTypeForNestedArrayExpr(checker::ETSChecker *const checker, ArrayExpression *const nestedArrayExpr, const std::size_t idx) const diff --git a/ets2panda/ir/expressions/arrayExpression.h b/ets2panda/ir/expressions/arrayExpression.h index f2028094c1..c49bd60998 100644 --- a/ets2panda/ir/expressions/arrayExpression.h +++ b/ets2panda/ir/expressions/arrayExpression.h @@ -121,6 +121,7 @@ public: } void ClearPreferredType(); + void CleanCheckInformation() override; [[nodiscard]] ArrayExpression *Clone(ArenaAllocator *allocator, AstNode *parent) override; diff --git a/ets2panda/ir/expressions/memberExpression.cpp b/ets2panda/ir/expressions/memberExpression.cpp index 4fde4e957d..ae65ae697c 100644 --- a/ets2panda/ir/expressions/memberExpression.cpp +++ b/ets2panda/ir/expressions/memberExpression.cpp @@ -207,6 +207,11 @@ checker::Type *MemberExpression::TraverseUnionMember(checker::ETSChecker *checke return; } + if (memberType->IsETSMethodType() && memberType->Variable()->HasFlag(varbinder::VariableFlags::OVERLOAD)) { + checker->LogError(diagnostic::OVERLOADED_UNION_CALL, {}, Start()); + return; + } + if (!commonPropType->IsETSMethodType() && !memberType->IsETSMethodType()) { if (!checker->IsTypeIdenticalTo(commonPropType, memberType)) { checker->LogError(diagnostic::MEMBER_TYPE_MISMATCH_ACROSS_UNION, {}, Start()); diff --git a/ets2panda/ir/expressions/objectExpression.cpp b/ets2panda/ir/expressions/objectExpression.cpp index 81da3dda08..062a325899 100644 --- a/ets2panda/ir/expressions/objectExpression.cpp +++ b/ets2panda/ir/expressions/objectExpression.cpp @@ -406,4 +406,11 @@ checker::VerifiedType ObjectExpression::Check(checker::ETSChecker *checker) { return {this, checker->GetAnalyzer()->Check(this)}; } + +void ObjectExpression::CleanCheckInformation() +{ + SetPreferredType(nullptr); + SetTsType(nullptr); + this->Iterate([&](auto *childNode) { childNode->CleanCheckInformation(); }); +} } // namespace ark::es2panda::ir diff --git a/ets2panda/ir/expressions/objectExpression.h b/ets2panda/ir/expressions/objectExpression.h index 350633d4df..7c7abd4ca7 100644 --- a/ets2panda/ir/expressions/objectExpression.h +++ b/ets2panda/ir/expressions/objectExpression.h @@ -119,6 +119,8 @@ public: SetPreferredType(nullptr); } + void CleanCheckInformation() override; + private: std::tuple CheckPatternIsShorthand( CheckPatternIsShorthandArgs *args); diff --git a/ets2panda/ir/opaqueTypeNode.cpp b/ets2panda/ir/opaqueTypeNode.cpp index 4a74b38975..e6d0623f08 100644 --- a/ets2panda/ir/opaqueTypeNode.cpp +++ b/ets2panda/ir/opaqueTypeNode.cpp @@ -77,4 +77,7 @@ checker::VerifiedType OpaqueTypeNode::Check([[maybe_unused]] checker::ETSChecker { return {this, checker->GetAnalyzer()->Check(this)}; } + +void OpaqueTypeNode::CleanCheckInformation() {} + } // namespace ark::es2panda::ir diff --git a/ets2panda/ir/opaqueTypeNode.h b/ets2panda/ir/opaqueTypeNode.h index f4871890a3..acc764870a 100644 --- a/ets2panda/ir/opaqueTypeNode.h +++ b/ets2panda/ir/opaqueTypeNode.h @@ -48,6 +48,7 @@ public: checker::Type *GetType([[maybe_unused]] checker::TSChecker *checker) override; checker::VerifiedType Check([[maybe_unused]] checker::ETSChecker *checker) override; checker::Type *GetType([[maybe_unused]] checker::ETSChecker *checker) override; + void CleanCheckInformation() override; void Accept(ASTVisitorT *v) override { diff --git a/ets2panda/lexer/scripts/keywords.yaml b/ets2panda/lexer/scripts/keywords.yaml index 3b03c20867..58cffbda4f 100644 --- a/ets2panda/lexer/scripts/keywords.yaml +++ b/ets2panda/lexer/scripts/keywords.yaml @@ -421,6 +421,10 @@ keywords: token: KEYW_OUT keyword_like: [ets] + - name: 'overload' + token: KEYW_OVERLOAD + keyword: [ets] + - name: 'override' token: KEYW_OVERRIDE keyword: [ets] diff --git a/ets2panda/parser/ETSparser.cpp b/ets2panda/parser/ETSparser.cpp index 3aae7a2ec9..aa2000a8af 100644 --- a/ets2panda/parser/ETSparser.cpp +++ b/ets2panda/parser/ETSparser.cpp @@ -635,9 +635,15 @@ ir::AstNode *ETSParser::ParseInnerConstructorDeclaration(ir::ModifierFlags membe 0) { LogError(diagnostic::INVALID_DECORATOR_CONSTRUCTOR); } - auto *memberName = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + + lexer::Token constructorToken = Lexer()->GetToken(); + Lexer()->TryEatTokenType(lexer::TokenType::KEYW_CONSTRUCTOR); memberModifiers |= ir::ModifierFlags::CONSTRUCTOR; - Lexer()->NextToken(); + + ir::Identifier *memberName = Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_IDENT + ? ExpectIdentifier(false, true) + : AllocNode(constructorToken.Ident(), Allocator()); + auto *classMethod = ParseClassMethodDefinition(memberName, memberModifiers, isDefault); classMethod->SetStart(startLoc); @@ -697,6 +703,12 @@ ir::AstNode *ETSParser::ParseInnerRest(const ArenaVector &propert } } + if (Lexer()->TryEatTokenFromKeywordType(lexer::TokenType::KEYW_OVERLOAD)) { + auto *classOverload = ParseClassOverloadDeclaration(memberModifiers); + classOverload->SetStart(startLoc); + return classOverload; + } + auto *memberName = ExpectIdentifier(false, false, TypeAnnotationParsingOptions::NO_OPTS); // don't report error if (memberName == nullptr) { // log error here LogUnexpectedToken(Lexer()->GetToken()); @@ -2144,6 +2156,81 @@ void ETSParser::CheckDeclare() } } +void ETSParser::ValidateOverloadDeclarationModifiers(ir::ModifierFlags modifiers) +{ + ir::ModifierFlags allowModifiers = + ir::ModifierFlags::STATIC | ir::ModifierFlags::ASYNC | ir::ModifierFlags::ACCESS | ir::ModifierFlags::EXPORTED; + if ((modifiers & ~allowModifiers) != 0) { + LogError(diagnostic::OVERLOAD_MODIFIERS); + } +} + +bool ETSParser::ParseOverloadListElement(ArenaVector &overloads, + ir::OverloadDeclaration *overloadDecl) +{ + if (Lexer()->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) { + LogExpectedToken(lexer::TokenType::LITERAL_IDENT); + } + ir::Expression *qualifiedName = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + qualifiedName->SetRange(Lexer()->GetToken().Loc()); + Lexer()->NextToken(); + while (Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_PERIOD)) { + if (Lexer()->GetToken().Type() != lexer::TokenType::LITERAL_IDENT) { + LogExpectedToken(lexer::TokenType::LITERAL_IDENT); + } + auto *identNode = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + identNode->SetRange(Lexer()->GetToken().Loc()); + auto start = qualifiedName->Start(); + qualifiedName = AllocNode(qualifiedName, identNode, + ir::MemberExpressionKind::PROPERTY_ACCESS, false, false); + qualifiedName->SetRange({start, identNode->End()}); + Lexer()->NextToken(); + } + + qualifiedName->SetParent(overloadDecl); + overloads.push_back(qualifiedName); + return true; +} + +ir::OverloadDeclaration *ETSParser::ParseOverloadDeclaration(ir::ModifierFlags modifiers) +{ + ValidateOverloadDeclarationModifiers(modifiers); + Lexer()->TryEatTokenKeyword(lexer::TokenType::KEYW_OVERLOAD); + auto *overloadName = ExpectIdentifier(false, true, TypeAnnotationParsingOptions::REPORT_ERROR); + auto *overloadDef = AllocNode(overloadName->Clone(Allocator(), nullptr)->AsExpression(), + modifiers, Allocator()); + overloadDef->AddOverloadDeclFlag(ir::OverloadDeclFlags::FUNCTION); + + auto startLoc = Lexer()->GetToken().Start(); + if (!Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_LEFT_BRACE)) { + LogExpectedToken(lexer::TokenType::PUNCTUATOR_LEFT_BRACE); + } + ArenaVector overloads(Allocator()->Adapter()); + lexer::SourcePosition endLoc; + + ParseList( + lexer::TokenType::PUNCTUATOR_RIGHT_BRACE, lexer::NextTokenFlags::NONE, + [this, &overloads, overloadDef]() { return ParseOverloadListElement(overloads, overloadDef); }, &endLoc, true); + overloadDef->SetOverloadedList(std::move(overloads)); + overloadDef->SetRange({startLoc, endLoc}); + for (ir::Expression *overloadedName : overloadDef->OverloadedList()) { + std::function checkQualifiedName = [&checkQualifiedName](ir::Expression *expr) -> bool { + if (expr->IsIdentifier()) { + return true; + } + if (expr->IsMemberExpression()) { + return expr->AsMemberExpression()->Property()->IsIdentifier() && + checkQualifiedName(expr->AsMemberExpression()->Object()); + } + return false; + }; + if (!checkQualifiedName(overloadedName)) { + LogError(diagnostic::FUNCTION_OVERLOADED_NAME_MUST_QUALIFIED_NAME, {}, overloadedName->Start()); + } + } + return overloadDef; +} + ir::FunctionDeclaration *ETSParser::ParseFunctionDeclaration(bool canBeAnonymous, ir::ModifierFlags modifiers) { lexer::SourcePosition startLoc = Lexer()->GetToken().Start(); diff --git a/ets2panda/parser/ETSparser.h b/ets2panda/parser/ETSparser.h index f72293d3da..46b62895de 100644 --- a/ets2panda/parser/ETSparser.h +++ b/ets2panda/parser/ETSparser.h @@ -231,12 +231,17 @@ private: ir::AstNode *ParseInterfaceField(); ir::TypeNode *ParseInterfaceTypeAnnotation(ir::Identifier *name); void ParseInterfaceModifiers(ir::ModifierFlags &fieldModifiers, bool &optionalField); + ir::OverloadDeclaration *ParseInterfaceOverload(ir::ModifierFlags modifiers); ir::MethodDefinition *ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind); void ReportAccessModifierError(const lexer::Token &token); std::tuple ParseClassMemberAccessModifiers(); ir::ModifierFlags ParseClassFieldModifiers(bool seenStatic); ir::ModifierFlags ParseClassMethodModifierFlag(); ir::ModifierFlags ParseClassMethodModifiers(bool seenStatic); + void ValidateOverloadDeclarationModifiers(ir::ModifierFlags modifiers); + bool ParseOverloadListElement(ArenaVector &overloads, ir::OverloadDeclaration *overloadDecl); + void ValidateOverloadList(ArenaVector const &overloadList); + ir::OverloadDeclaration *ParseClassOverloadDeclaration(ir::ModifierFlags modifiers); ir::MethodDefinition *ParseClassMethodDefinition(ir::Identifier *methodName, ir::ModifierFlags modifiers, bool isDefault); ir::ScriptFunction *ParseFunction(ParserStatus newStatus); @@ -391,6 +396,7 @@ private: ir::Statement *ParseInterfaceDeclaration(bool isStatic) override; ir::TypeNode *ParseThisType(TypeAnnotationParsingOptions *options); ir::Statement *ParseFunctionStatement(StatementParsingFlags flags) override; + ir::OverloadDeclaration *ParseOverloadDeclaration(ir::ModifierFlags modifiers); ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous, ir::ModifierFlags modifiers); ir::FunctionDeclaration *ParseAccessorWithReceiver(ir::ModifierFlags modifiers); ir::TypeNode *ParseExtensionFunctionsTypeAnnotation(); diff --git a/ets2panda/parser/ETSparserClasses.cpp b/ets2panda/parser/ETSparserClasses.cpp index 1241c1b768..35f4209441 100644 --- a/ets2panda/parser/ETSparserClasses.cpp +++ b/ets2panda/parser/ETSparserClasses.cpp @@ -514,6 +514,50 @@ void ETSParser::ParseClassFieldDefinition(ir::Identifier *fieldName, ir::Modifie declarations->push_back(field); } +void ETSParser::ValidateOverloadList(ArenaVector const &overloadList) +{ + for (ir::Expression *overloadedName : overloadList) { + if (!overloadedName->IsIdentifier()) { + LogError(diagnostic::CLASS_INTERFACE_METHOD_OVERLOADED_NAME_MUST_IDENT, {}, overloadedName->Start()); + } + } +} + +ir::OverloadDeclaration *ETSParser::ParseClassOverloadDeclaration(ir::ModifierFlags modifiers) +{ + ValidateOverloadDeclarationModifiers(modifiers); + ir::Identifier *overloadName = nullptr; + // To avoid duplicate names with anonymous constructors, overload constructor name is + // "constructorOverloadDeclaration", instead of "constructor" + if (Lexer()->GetToken().Type() == lexer::TokenType::KEYW_CONSTRUCTOR) { + overloadName = + AllocNode(compiler::Signatures::CONSTRUCTOR_OVERLOAD_DEFINITION_NAME, Allocator()); + modifiers |= ir::ModifierFlags::CONSTRUCTOR; + Lexer()->NextToken(); + } else { + overloadName = ExpectIdentifier(false, true, TypeAnnotationParsingOptions::REPORT_ERROR); + } + + auto *overloadDef = AllocNode(overloadName->Clone(Allocator(), nullptr)->AsExpression(), + modifiers, Allocator()); + overloadDef->AddOverloadDeclFlag(ir::OverloadDeclFlags::CLASS_METHOD); + + auto startLoc = Lexer()->GetToken().Start(); + if (!Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_LEFT_BRACE)) { + LogExpectedToken(lexer::TokenType::PUNCTUATOR_LEFT_BRACE); + } + ArenaVector overloads(Allocator()->Adapter()); + lexer::SourcePosition endLoc; + + ParseList( + lexer::TokenType::PUNCTUATOR_RIGHT_BRACE, lexer::NextTokenFlags::NONE, + [this, &overloads, overloadDef]() { return ParseOverloadListElement(overloads, overloadDef); }, &endLoc, true); + overloadDef->SetOverloadedList(std::move(overloads)); + overloadDef->SetRange({startLoc, endLoc}); + ValidateOverloadList(overloadDef->OverloadedList()); + return overloadDef; +} + ir::MethodDefinition *ETSParser::ParseClassMethodDefinition(ir::Identifier *methodName, ir::ModifierFlags modifiers, bool isDefault) { @@ -930,7 +974,8 @@ ir::ModifierFlags ETSParser::ParseInterfaceMethodModifiers() { if (Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_IDENT || Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_SQUARE_BRACKET || - Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) { + Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS || + Lexer()->GetToken().Type() == lexer::TokenType::KEYW_OVERLOAD) { return ir::ModifierFlags::PUBLIC; } @@ -1044,6 +1089,31 @@ static lexer::SourcePosition GetEndLoc(ir::BlockStatement *body, ir::ScriptFunct return lexer->GetToken().End(); } +ir::OverloadDeclaration *ETSParser::ParseInterfaceOverload(ir::ModifierFlags modifiers) +{ + ValidateOverloadDeclarationModifiers(modifiers); + auto *overloadName = ExpectIdentifier(false, true, TypeAnnotationParsingOptions::REPORT_ERROR); + auto *overloadDef = AllocNode(overloadName->Clone(Allocator(), nullptr)->AsExpression(), + modifiers, Allocator()); + overloadDef->AddOverloadDeclFlag(ir::OverloadDeclFlags::INTERFACE_METHOD); + + auto startLoc = Lexer()->GetToken().Start(); + if (!Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_LEFT_BRACE)) { + LogExpectedToken(lexer::TokenType::PUNCTUATOR_LEFT_BRACE); + } + ArenaVector overloads(Allocator()->Adapter()); + lexer::SourcePosition endLoc; + + ParseList( + lexer::TokenType::PUNCTUATOR_RIGHT_BRACE, lexer::NextTokenFlags::NONE, + [this, &overloads, overloadDef]() { return ParseOverloadListElement(overloads, overloadDef); }, &endLoc, true); + + overloadDef->SetOverloadedList(std::move(overloads)); + overloadDef->SetRange({startLoc, endLoc}); + ValidateOverloadList(overloadDef->OverloadedList()); + return overloadDef; +} + ir::MethodDefinition *ETSParser::ParseInterfaceMethod(ir::ModifierFlags flags, ir::MethodDefinitionKind methodKind) { ir::Identifier *name = nullptr; @@ -1168,6 +1238,12 @@ ir::AstNode *ETSParser::ParseTypeLiteralOrInterfaceMember() auto readonlyTok = Lexer()->TryEatTokenKeyword(lexer::TokenType::KEYW_READONLY); bool isReadonly = readonlyTok.has_value(); + if (Lexer()->TryEatTokenFromKeywordType(lexer::TokenType::KEYW_OVERLOAD)) { + auto *overloadDeclaration = ParseInterfaceOverload(modifiers); + overloadDeclaration->SetStart(startLoc); + return overloadDeclaration; + } + if (nextCp == lexer::LEX_CHAR_LEFT_PAREN || nextCp == lexer::LEX_CHAR_LESS_THAN) { if (isReadonly) { LogError(diagnostic::READONLY_INTERFACE_METHOD, {}, startLoc); @@ -1332,7 +1408,8 @@ std::pair ETSParser::ParseMemberModifi } Lexer()->NextToken(); - if (Lexer()->GetToken().Type() != lexer::TokenType::KEYW_FUNCTION) { + if (Lexer()->GetToken().Type() != lexer::TokenType::KEYW_FUNCTION && + Lexer()->GetToken().KeywordType() != lexer::TokenType::KEYW_OVERLOAD) { // async_function_bas.ets if (isAsync) { LogError(diagnostic::ASYNC_FLAG_ONLY_FOR_TOP_FUN); diff --git a/ets2panda/parser/ETSparserStatements.cpp b/ets2panda/parser/ETSparserStatements.cpp index f59b4794d5..7f59b8b0e3 100644 --- a/ets2panda/parser/ETSparserStatements.cpp +++ b/ets2panda/parser/ETSparserStatements.cpp @@ -179,6 +179,7 @@ bool ETSParser::IsInitializerBlockStart() const return validStart; } +// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP, G.FUD.05) solid logic, big switch case ir::Statement *ETSParser::ParseTopLevelDeclStatement(StatementParsingFlags flags) { auto [memberModifiers, startLoc] = ParseMemberModifiers(); @@ -209,6 +210,9 @@ ir::Statement *ETSParser::ParseTopLevelDeclStatement(StatementParsingFlags flags case lexer::TokenType::KEYW_CLASS: result = ParseTypeDeclaration(IsInitializerBlockStart()); break; + case lexer::TokenType::KEYW_OVERLOAD: + result = ParseOverloadDeclaration(memberModifiers); + break; case lexer::TokenType::PUNCTUATOR_AT: result = ParseTopLevelAnnotation(memberModifiers); break; diff --git a/ets2panda/parser/parserImpl.cpp b/ets2panda/parser/parserImpl.cpp index 4f66296e62..b5c33731a2 100644 --- a/ets2panda/parser/parserImpl.cpp +++ b/ets2panda/parser/parserImpl.cpp @@ -683,7 +683,7 @@ ir::MethodDefinition *ParserImpl::BuildImplicitConstructor(ir::ClassDefinitionMo } auto *ctor = AllocNode(ir::MethodDefinitionKind::CONSTRUCTOR, key, funcExpr, - ir::ModifierFlags::NONE, Allocator(), false); + ir::ModifierFlags::CONSTRUCTOR, Allocator(), false); const auto rangeImplicitContstuctor = lexer::SourceRange(startLoc, startLoc); ctor->IterateRecursively( diff --git a/ets2panda/public/CMakeLists.txt b/ets2panda/public/CMakeLists.txt index a5f869fddb..5440dba17c 100644 --- a/ets2panda/public/CMakeLists.txt +++ b/ets2panda/public/CMakeLists.txt @@ -250,6 +250,7 @@ set (HEADERS_TO_BE_PARSED ${ES2PANDA_ROOT}/ir/ts/tsImportEqualsDeclaration.h ${ES2PANDA_ROOT}/ir/validationInfo.h ${ES2PANDA_ROOT}/ir/base/methodDefinition.h + ${ES2PANDA_ROOT}/ir/base/overloadDeclaration.h ${ES2PANDA_ROOT}/ir/ts/tsIntersectionType.h ${ES2PANDA_ROOT}/checker/types/ts/nullType.h ${ES2PANDA_ROOT}/checker/types/ts/unknownType.h @@ -499,6 +500,7 @@ set (ES2PANDA_API_GENERATED ${LIBGEN_DIR}/gen/headers/ir/expressions/directEvalExpression.yaml ${LIBGEN_DIR}/gen/headers/ir/ts/tsTypeParameterDeclaration.yaml ${LIBGEN_DIR}/gen/headers/ir/base/methodDefinition.yaml + ${LIBGEN_DIR}/gen/headers/ir/base/overloadDeclaration.yaml ${LIBGEN_DIR}/gen/headers/ir/ts/tsNullKeyword.yaml ${LIBGEN_DIR}/gen/headers/ir/ts/tsInterfaceHeritage.yaml ${LIBGEN_DIR}/gen/headers/checker/types/ts/enumLiteralType.yaml diff --git a/ets2panda/public/headers_parser/supported_types.py b/ets2panda/public/headers_parser/supported_types.py index 3934a02ee8..c10aabea13 100644 --- a/ets2panda/public/headers_parser/supported_types.py +++ b/ets2panda/public/headers_parser/supported_types.py @@ -64,6 +64,7 @@ ast_nodes_supported = [ "MemberExpression", "MetaProperty", "MethodDefinition", + "OverloadDeclaration", "NamedType", "NewExpression", "NullLiteral", diff --git a/ets2panda/test/ast/compiler/ets/first_match/abstract_method.ets b/ets2panda/test/ast/compiler/ets/first_match/abstract_method.ets new file mode 100644 index 0000000000..c79e3ffb02 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/abstract_method.ets @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2025 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. + */ + +abstract class Base { + abstract fooNumber(a: number): string; + abstract fooString(a: string): string; + overload foo {/* @@ label1 */fooNumber,/* @@ label2 */fooString } +} + +/* @@@ label1 Error TypeError: overload declaration cannot contain abstract methods. */ +/* @@@ label2 Error TypeError: overload declaration cannot contain abstract methods. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/access_modifiers.ets b/ets2panda/test/ast/compiler/ets/first_match/access_modifiers.ets new file mode 100644 index 0000000000..46cd5f3a15 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/access_modifiers.ets @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + private fooPrivate(x: string) {} + protected fooProtected(x: number) {} + public fooPublic(x: boolean) {} + + overload foo{ fooPrivate, fooProtected, fooPublic } + + bar(){ + this.foo("abc"); + this.foo(1); + this.foo(true); + } +} + +class Sub extends Base { + bar() { + /* @@ label1 */this.foo("abc"); + this.foo(1); + this.foo(true); + } +} + +function main() { + let a = new Base(); + /* @@ label2 */a.foo("abc"); + /* @@ label3 */a.foo(1); + a.foo(true); +} + +/* @@@ label1 Error TypeError: Signature fooPrivate(x: String): void is not visible here. */ +/* @@@ label1 Error TypeError: No matching call signature for foo("abc") */ +/* @@@ label2 Error TypeError: Signature fooPrivate(x: String): void is not visible here. */ +/* @@@ label2 Error TypeError: No matching call signature for foo("abc") */ +/* @@@ label3 Error TypeError: Signature fooProtected(x: Double): void is not visible here. */ +/* @@@ label3 Error TypeError: No matching call signature for foo(Int) */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/access_modifiers_2.ets b/ets2panda/test/ast/compiler/ets/first_match/access_modifiers_2.ets new file mode 100644 index 0000000000..8c7362de22 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/access_modifiers_2.ets @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test1 { + foo1(a: number) { } + foo2(a: string) { } + native overload foo{ foo1, foo2 } +} + +class Test2 { + foo1(a: number) { } + foo2(a: string) { } + readonly overload foo{ foo1, foo2 } +} + +class Test3 { + foo1(a: number) { } + foo2(a: string) { } + abstract overload foo{ foo1, foo2 } +} + +/* @@? 19:21 Error SyntaxError: Overload Declaration only allow use modifier 'static' | 'async'. */ +/* @@? 25:23 Error SyntaxError: Overload Declaration only allow use modifier 'static' | 'async'. */ +/* @@? 31:23 Error SyntaxError: Overload Declaration only allow use modifier 'static' | 'async'. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/arrayliteral.ets b/ets2panda/test/ast/compiler/ets/first_match/arrayliteral.ets new file mode 100644 index 0000000000..7e8ca5089a --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/arrayliteral.ets @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test{ + foo1(a:[string,string,string]){ + console.log("invoke1") + } + foo2(a:[number,string,boolean]){ + console.log("invoke2") + } + foo3(a:number[]){ + console.log("invoke3") + } + + overload foo111{foo1,foo2,foo3} +} + +function main(){ + let a:Test = new Test(); + a.foo111(["abc","abc",1]); + a.foo111(["abc","abc",true]); + a.foo111([123,"abc",true]); + a.foo111([123,123,123]); +} + +/* @@? 32:5 Error TypeError: No matching call signature for foo111(Array) */ +/* @@? 33:5 Error TypeError: No matching call signature for foo111(Array) */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/constructor.ets b/ets2panda/test/ast/compiler/ets/first_match/constructor.ets new file mode 100644 index 0000000000..db1517374c --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/constructor.ets @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test1{ + constructor(a?:number,b?:number){} + constructor con1(){} + overload constructor{con1} +} + +class Test2{ + constructor(a:number,b:number){} + constructor con1(){} + overload constructor{con1} +} + +class Test3{ + constructor(a:number,...args:[string,number]){} + constructor con1(){} + overload constructor{con1} +} + +class Test4{ + constructor(a?:number,b?:number){} + constructor(a:string){} + constructor con1(){} + /* @@ label1 */constructor con1(){} + /* @@ label2 */overload constructor{con1} +} + +class Test5{ + constructor(a:number,...args:[string,number]){} + constructor(a:string){} + constructor con1(){} + /* @@ label3 */overload constructor{con1} +} + +/* @@@ label1 Error TypeError: Function con1 is already declared. */ +/* @@@ label2 Error TypeError: The overloaded name 'constructor' can't refer to a function with overload signatures. */ +/* @@@ label2 Error TypeError: The overloaded name 'con1' can't refer to a function with overload signatures. */ +/* @@@ label3 Error TypeError: The overloaded name 'constructor' can't refer to a function with overload signatures. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration.ets b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration.ets new file mode 100644 index 0000000000..0d0f584988 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration.ets @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(a: number) { } + foo2(a: string) { } + overload: foo{ foo1, foo2 } +} + +/* @@? 19:13 Error SyntaxError: Identifier expected, got ':'. */ +/* @@? 19:15 Error SyntaxError: Unexpected token, expected '{'. */ +/* @@? 19:15 Error SyntaxError: Unexpected token, expected an identifier. */ +/* @@? 19:15 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 19:18 Error SyntaxError: Unexpected token, expected ',' or '}'. */ +/* @@? 19:18 Error SyntaxError: Unexpected token '{'. */ +/* @@? 19:20 Error TypeError: Variable 'foo1' has already been declared. */ +/* @@? 19:24 Error SyntaxError: Field type annotation expected. */ +/* @@? 19:24 Error SyntaxError: Unexpected token ','. */ +/* @@? 19:26 Error TypeError: Variable 'foo2' has already been declared. */ +/* @@? 19:31 Error SyntaxError: Field type annotation expected. */ +/* @@? 20:1 Error SyntaxError: Unexpected token '}'. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_2.ets b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_2.ets new file mode 100644 index 0000000000..63be2fcf48 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_2.ets @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + foo1(a: number) { } + foo2(a: string) { } + overload foo(foo1, foo2) +} + +/* @@? 19:17 Error SyntaxError: Unexpected token, expected '{'. */ +/* @@? 19:17 Error SyntaxError: Unexpected token, expected an identifier. */ +/* @@? 19:17 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 19:18 Error SyntaxError: Unexpected token, expected ',' or '}'. */ +/* @@? 19:18 Error TypeError: Variable 'foo1' has already been declared. */ +/* @@? 19:22 Error SyntaxError: Field type annotation expected. */ +/* @@? 19:22 Error SyntaxError: Unexpected token ','. */ +/* @@? 19:24 Error TypeError: Variable 'foo2' has already been declared. */ +/* @@? 19:28 Error SyntaxError: Field type annotation expected. */ +/* @@? 19:28 Error SyntaxError: Unexpected token ')'. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_3.ets b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_3.ets new file mode 100644 index 0000000000..c6e43822e8 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_3.ets @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + foo1(a: number) { } + foo2(a: string) { } + overload { foo1, foo2 } +} + +/* @@? 19:14 Error SyntaxError: Identifier expected, got '{'. */ +/* @@? 19:16 Error SyntaxError: Unexpected token, expected '{'. */ +/* @@? 19:16 Error SyntaxError: Unexpected token, expected an identifier. */ +/* @@? 19:16 Error TypeError: overloaded name must refer to an accessible method. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_4.ets b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_4.ets new file mode 100644 index 0000000000..a3d50ec721 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/invalid_declaration_4.ets @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + foo1(a: number) { } + foo2(a: string) { } + overload foo{ fo, fo2 } +} + +/* @@? 19:19 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 19:23 Error TypeError: overloaded name must refer to an accessible method. */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/invalid_identifier.ets b/ets2panda/test/ast/compiler/ets/first_match/invalid_identifier.ets new file mode 100644 index 0000000000..ae4fa8c990 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/invalid_identifier.ets @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test{ + foo1(a:[string,string,string]){ + console.log("invoke1") + } + + overload foo111(foo1,foo2,foo3){} //syntaxError, do not crash + overload foo112(foo1,foo2) //syntaxError, do not crash +} + +function main(){ + let a:Test = new Test(); + a.foo111(["abc","abc",1]); +} + +/* @@? 21:20 Error SyntaxError: Unexpected token, expected an identifier. */ +/* @@? 21:20 Error SyntaxError: Unexpected token, expected '{'. */ +/* @@? 21:20 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 21:21 Error SyntaxError: Unexpected token, expected ',' or '}'. */ +/* @@? 21:21 Error TypeError: Variable 'foo1' has already been declared. */ +/* @@? 21:25 Error SyntaxError: Field type annotation expected. */ +/* @@? 21:25 Error SyntaxError: Unexpected token ','. */ +/* @@? 21:30 Error SyntaxError: Field type annotation expected. */ +/* @@? 21:30 Error SyntaxError: Unexpected token ','. */ +/* @@? 21:35 Error SyntaxError: Field type annotation expected. */ +/* @@? 21:35 Error SyntaxError: Unexpected token ')'. */ +/* @@? 21:36 Error SyntaxError: Unexpected token '{'. */ +/* @@? 22:20 Error SyntaxError: Unexpected token, expected '{'. */ +/* @@? 22:20 Error SyntaxError: Unexpected token, expected an identifier. */ +/* @@? 22:20 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 22:21 Error SyntaxError: Unexpected token, expected ',' or '}'. */ +/* @@? 22:21 Error TypeError: Unresolved reference foo1 */ +/* @@? 22:25 Error SyntaxError: Unexpected token ','. */ +/* @@? 22:26 Error SyntaxError: Unexpected token 'foo2'. */ +/* @@? 22:26 Error TypeError: Unresolved reference foo2 */ +/* @@? 22:30 Error SyntaxError: Unexpected token ')'. */ +/* @@? 23:1 Error SyntaxError: Unexpected token '}'. */ +/* @@? 27:7 Error TypeError: Property 'foo111' does not exist on type 'Test' */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/invalid_paramter.ets b/ets2panda/test/ast/compiler/ets/first_match/invalid_paramter.ets new file mode 100644 index 0000000000..ab6be8fcab --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/invalid_paramter.ets @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2025 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. + */ + +class A {} +class B {} + +class Test { + foo1(a?: A,) { + console.log("invoke1") + } + foo2(a?: A, b?: B) { + console.log("invoke2") + } + + overload foo111{ foo1, foo2, foo3, foo4 } +} + +function main() { + let a: Test = new Test(); + a.foo111(new A(), new A()) + a.foo111(new A(), new A(), new A()) +} + +/* @@? 27:34 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 27:40 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@? 32:5 Error TypeError: No matching call signature for foo111(A, A) */ +/* @@? 33:5 Error TypeError: No matching call signature for foo111(A, A, A) */ + diff --git a/ets2panda/test/ast/compiler/ets/first_match/modifier_async.ets b/ets2panda/test/ast/compiler/ets/first_match/modifier_async.ets new file mode 100644 index 0000000000..1c3ba11c80 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/modifier_async.ets @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base1 { + async fooNumber(a: number): Promise {} + fooString(a: string): void {} + overload foo {/* @@ label1 */fooNumber, fooString } +} + +class Base2 { + async fooNumber(a: number): Promise {} + fooString(a: string): void {} + async overload foo {fooNumber, /* @@ label2 */fooString } +} + +/* @@@ label1 Error TypeError: Overload alias and overloaded method name must have exactly the same modifiers (static, async). */ +/* @@@ label2 Error TypeError: Overload alias and overloaded method name must have exactly the same modifiers (static, async). */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/modifier_static.ets b/ets2panda/test/ast/compiler/ets/first_match/modifier_static.ets new file mode 100644 index 0000000000..216411ca48 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/modifier_static.ets @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base1 { + static fooNumber(a: number): void {} + fooString(a: string): void {} + overload foo {/* @@ label1 */fooNumber, fooString } +} + +class Base2 { + static fooNumber(a: number): void {} + fooString(a: string): void {} + static overload foo {fooNumber, /* @@ label2 */fooString } +} + +/* @@@ label1 Error TypeError: Overload alias and overloaded method name must have exactly the same modifiers (static, async). */ +/* @@@ label2 Error TypeError: Overload alias and overloaded method name must have exactly the same modifiers (static, async). */ diff --git a/ets2panda/test/ast/compiler/ets/first_match/override.ets b/ets2panda/test/ast/compiler/ets/first_match/override.ets new file mode 100644 index 0000000000..2bb8873b99 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/first_match/override.ets @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base{ + overload foo {fooNumber,fooString} + fooNumber(a:number):string{ + return "invoke1"; + } + fooString(a:string):string{ + return "invoke2"; + } +} + +class Sub1 extends Base{ + override fooNumber(a:number):string{ + return "invoke3"; + } +} + +class Sub2 extends Base{ + fooInt(a:int):string{ + return "invoke4"; + } + overload foo{fooInt,fooNumber} +} + +/* @@? 32:20 Error TypeError: Cannot inherit from class Base, because overload foo is inherited with a different declaration type */ diff --git a/ets2panda/test/ast/compiler/ets/overload/class_overloaded_name_must_ident.ets b/ets2panda/test/ast/compiler/ets/overload/class_overloaded_name_must_ident.ets new file mode 100644 index 0000000000..6559e6d66b --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/class_overloaded_name_must_ident.ets @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2025 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. + */ + +class B { + foo1() {} +} + +class C { + overload foo { /* @@label1 */B.foo1 } +} + +/* @@@ label1 Error SyntaxError: The overloaded method name in class/interface method overload declaration must be identifier. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/constructor_overloaded_name_must_ident.ets b/ets2panda/test/ast/compiler/ets/overload/constructor_overloaded_name_must_ident.ets new file mode 100644 index 0000000000..d4a9648f60 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/constructor_overloaded_name_must_ident.ets @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2025 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. + */ + +class B { + constructor foo1() {} +} + +class C { + overload constructor { /* @@label1 */B.foo1 } +} + +/* @@@ label1 Error SyntaxError: The overloaded method name in class/interface method overload declaration must be identifier. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/function_overloaded_name_must_qualified_name.ets b/ets2panda/test/ast/compiler/ets/overload/function_overloaded_name_must_qualified_name.ets new file mode 100644 index 0000000000..70eb87ba28 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/function_overloaded_name_must_qualified_name.ets @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2025 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. + */ + + +namespace NS { + export function foo1() {} + export class A { + static foo2() {} + } +} + +overload foo {NS.foo1, NS.A.foo2, /* @@ label1 */NS.A.foo2} + +/* @@@ label1 Error TypeError: Duplicate overloaded method. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/interface_overloaded_name_must_ident.ets b/ets2panda/test/ast/compiler/ets/overload/interface_overloaded_name_must_ident.ets new file mode 100644 index 0000000000..3d5f01eb89 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/interface_overloaded_name_must_ident.ets @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2025 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. + */ +class B { + foo1() {} +} + +interface I { + overload foo { /* @@label1 */B.foo1 } +} + +/* @@@ label1 Error SyntaxError: The overloaded method name in class/interface method overload declaration must be identifier. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function.ets b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function.ets new file mode 100644 index 0000000000..3b4308b99f --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function.ets @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { } +class B { } +class C { } + +function foo111(a: A): A { + return a; +} +function foo112(a: B): B { + return a; +} + +function foo113(a: C): C { + return a; +} + +overload foo{ foo111, foo112, foo113,/* @@ label1 */foo111 } + +/* @@@ label1 Error TypeError: Duplicate overloaded method. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function_2.ets b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function_2.ets new file mode 100644 index 0000000000..fa182d50da --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_function_2.ets @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2025 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. + */ + +namespace NS { + export namespace NS2 { + export function foo1(a: string): string { + return "invoke1" + }; + export namespace NS3 { + export function foo2(a: number): string { + return "invoke2" + }; + } + } + + export function foo3(a: boolean): string { + return "invoke3" + }; +} + + +overload foo{ NS.NS2.foo1, NS.NS2.NS3.foo2, NS.foo3, /* @@ label1 */NS.NS2.NS3.foo2}; + +/* @@@ label1 Error TypeError: Duplicate overloaded method. */ + diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_method.ets b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_method.ets new file mode 100644 index 0000000000..2d656eb4b7 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_method.ets @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { } +class B { } +class C { } + +class Test1 { + foo111(a: A): A { + return a; + } + foo112(a: B): B { + return a; + } + + foo113(a: C): C { + return a; + } + overload foo{ foo111, foo112, foo113,/* @@ label1 */foo111 } +} + +/* @@@ label1 Error TypeError: Duplicate overloaded method. */ \ No newline at end of file diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_overload_name_1.ets b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_overload_name_1.ets new file mode 100644 index 0000000000..95eddfc644 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_duplicate_overload_name_1.ets @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + foo/* @@ label1 */(a: number) : string + foo(a: string) : string + overload /* @@ label2 */foo {/* @@ label3 */foo, /* @@ label4 */foo} +} + +/* @@@ label1 Error TypeError: Only abstract or native methods can't have body. */ +/* @@@ label2 Error TypeError: Variable 'foo' has already been declared. */ +/* @@@ label3 Error TypeError: overloaded name must refer to an accessible method. */ +/* @@@ label4 Error TypeError: Duplicate overloaded method. */ +/* @@@ label4 Error TypeError: overloaded name must refer to an accessible method. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_from_super_class.ets b/ets2panda/test/ast/compiler/ets/overload/overload_from_super_class.ets new file mode 100644 index 0000000000..81f8d0f398 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_from_super_class.ets @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2025 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. + */ + + +class B extends A { + fooB() { + } + overload foo{fooB, fooA} +} + +class A{ + fooA() {} +} + diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_method_exported.ets b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_method_exported.ets new file mode 100644 index 0000000000..b5511a3f9e --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_method_exported.ets @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2025 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. + */ + +export function foo1() {} +function foo2() {} +export overload foo {foo1, /* @@ label1 */foo2} + +/* @@@ label1 Error TypeError: Overload alias is exported, then overload functions must also be exported. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_at_most_once_1.ets b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_at_most_once_1.ets new file mode 100644 index 0000000000..1a2ab17c31 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_at_most_once_1.ets @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} +class B{} + +class Test0 { + foo111(a: A): void { } +} + +class Test1 extends Test0 { + + foo112(a: B): B { + return a; + } + overload foo{foo111, /* @@ label1 */foo111, foo112} +} + +/* @@@ label1 Error TypeError: Duplicate overloaded method. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_1.ets b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_1.ets new file mode 100644 index 0000000000..dec7657edd --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_1.ets @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2025 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. + */ + + +class E { + foo1() {} + foo2() {} + overload foo{foo1, foo2} + foo3() { + let f = this.foo; + } +} + +/* @@? 22:22 Error TypeError: Overloaded method is used as value */ + diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_2.ets b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_2.ets new file mode 100644 index 0000000000..19db7f31f9 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_overloaded_name_used_as_value_2.ets @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2025 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. + */ + + + +function foo1() {} +function foo2() {} +overload foo{foo1, foo2} +let OL = /* @@ label */foo; + +/* @@@ label Error TypeError: Identifier 'foo' is used in wrong context. */ +/* @@@ label Error TypeError: Overloaded method is used as value */ +/* @@@ label Error TypeError: Identifier 'foo' is used in wrong context. */ +/* @@@ label Error TypeError: Overloaded method is used as value */ + diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_union_call.ets b/ets2panda/test/ast/compiler/ets/overload/overload_union_call.ets new file mode 100644 index 0000000000..f377a79a6a --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_union_call.ets @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + foo2(a: int) { } + foo1() { + return 1 + } + overload foo{ foo1, foo2 } +} + +class B { + foo2(a: int) { } + foo1() { + return 2 + } + overload foo{ foo1, foo2 } +} + +type AAA = A | B + +function foo(a: T) { + return /* @@ label1 */a.foo() +} + +/* @@@ label1 Error TypeError: Overload declaration cannot be called by union. */ diff --git a/ets2panda/test/ast/compiler/ets/overload/overload_union_call_2.ets b/ets2panda/test/ast/compiler/ets/overload/overload_union_call_2.ets new file mode 100644 index 0000000000..e718f62443 --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/overload/overload_union_call_2.ets @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + foo2(a: int) { } + foo1() { + return 1 + } + overload foo{ foo1, foo2 } +} + +class B { + foo() { } +} + +type AAA = A | B + +function foo(a: T) { + return /* @@ label1 */a.foo() +} + +/* @@@ label1 Error TypeError: Member type must be the same for all union objects. */ +/* @@@ label1 Error TypeError: No matching call signature */ diff --git a/ets2panda/test/ast/parser/ets/overload_class_method_test.ets b/ets2panda/test/ast/parser/ets/overload_class_method_test.ets new file mode 100644 index 0000000000..ad83ee5240 --- /dev/null +++ b/ets2panda/test/ast/parser/ets/overload_class_method_test.ets @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} +class B{} +class C{} + +class Test1 { + foo111(a: A): A { + return a; + } + foo112(a: B): B { + return a; + } + + foo113(a: C): C { + console.log(a) + return a; + } + overload foo{foo111,foo112,foo113} +} diff --git a/ets2panda/test/ast/parser/ets/overload_constructor.ets b/ets2panda/test/ast/parser/ets/overload_constructor.ets new file mode 100644 index 0000000000..4a250cf986 --- /dev/null +++ b/ets2panda/test/ast/parser/ets/overload_constructor.ets @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { } +class B { } +class C { } + +class Test1 { + constructor fromA(a: A){ } + constructor fromB(a: B){ } + constructor fromC(a: C){ } + + overload constructor { fromA, fromB, fromC } +} + +class Test2 { + constructor() { } + constructor fromA(a: A){ } + constructor fromB(a: B){ } + + overload constructor { fromA, fromB } +} diff --git a/ets2panda/test/ast/parser/ets/overload_global_function_our_style_test.ets b/ets2panda/test/ast/parser/ets/overload_global_function_our_style_test.ets new file mode 100644 index 0000000000..4237ee173f --- /dev/null +++ b/ets2panda/test/ast/parser/ets/overload_global_function_our_style_test.ets @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} +class B{} +class C{} + +function foo111(a: A): A { + return a; +} +function foo112(a: B): B { + return a; +} + +function foo113(a: C): C { + console.log(a) + return a; +} + +overload foo{ foo111, foo112, foo113 } diff --git a/ets2panda/test/ast/parser/ets/overload_interface_method_test.ets b/ets2panda/test/ast/parser/ets/overload_interface_method_test.ets new file mode 100644 index 0000000000..d418c4eacf --- /dev/null +++ b/ets2panda/test/ast/parser/ets/overload_interface_method_test.ets @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} +class B{} +class C{} + +interface Test1 { + foo111(a: A): A; + foo112(a: B): B; + foo113(a: C): C; + overload foo{foo111,foo112,foo113}; +} diff --git a/ets2panda/test/ast/parser/ets/overload_modifier_overloaddefinition.ets b/ets2panda/test/ast/parser/ets/overload_modifier_overloaddefinition.ets new file mode 100644 index 0000000000..c261c9fca0 --- /dev/null +++ b/ets2panda/test/ast/parser/ets/overload_modifier_overloaddefinition.ets @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} +class B{} +class C{} +class TempAny{} + +class Test1 { + async foo111(a: A): Promise { + return a; + } + async foo112(a: B): Promise { + return a; + } + + async foo113(a: C): Promise { + console.log(a) + return a; + } + async overload foo{foo111,foo112,foo113} +} + +class Test2 { + static foo111(a: A): A { + return a; + } + static foo112(a: B): B { + return a; + } + + static foo113(a: C): C { + console.log(a) + return a; + } + static overload foo{foo111,foo112,foo113} +} + +class Test3 { + private foo111(a: A): A { + return a; + } + private foo112(a: B): B { + return a; + } + + private foo113(a: C): C { + console.log(a) + return a; + } + private overload foo{foo111,foo112,foo113} +} diff --git a/ets2panda/test/runtime/ets/first_match/access_modifiers.ets b/ets2panda/test/runtime/ets/first_match/access_modifiers.ets new file mode 100644 index 0000000000..c8affb5755 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/access_modifiers.ets @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + private fooPrivate(x: string): string { + return "invoke1" + } + protected fooProtected(x: number): string { + return "invoke2" + } + public fooPublic(x: boolean): string { + return "invoke3" + } + + overload foo{ fooPrivate, fooProtected, fooPublic } + + test(){ + arktest.assertEQ(this.foo("abc"), "invoke1"); + arktest.assertEQ(this.foo(1), "invoke2"); + arktest.assertEQ(this.foo(true), "invoke3"); + } +} + +class Sub extends Base { + test() { + arktest.assertEQ(this.foo(1), "invoke2"); + arktest.assertEQ(this.foo(true), "invoke3"); + } +} + +function main() { + let a = new Base(); + arktest.assertEQ(a.foo(true), "invoke3"); + a.test(); + + let b = new Sub(); + b.test(); +} diff --git a/ets2panda/test/runtime/ets/first_match/array.ets b/ets2panda/test/runtime/ets/first_match/array.ets new file mode 100644 index 0000000000..5ca310bce3 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/array.ets @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(a: string[]): string { + return "invoke1" + } + foo2(a: number[]): string { + return "invoke2" + } + foo3(a: Array): string { + return "invoke3" + } + foo4(a: Array): string { + return "invoke4" + } + foo5(a: string[][]): string { + return "invoke5" + } + foo6(a: number[][]): string { + return "invoke6" + } + + overload foo{ foo1, foo2, foo3, foo4, foo5, foo6 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo([123, 123, 123]), "invoke2"); + arktest.assertEQ(a.foo(new number[5]), "invoke2"); + arktest.assertEQ(a.foo(new Array(2)), "invoke2"); + arktest.assertEQ(a.foo(new number[5][10]), "invoke6"); +} diff --git a/ets2panda/test/runtime/ets/first_match/array_and_tuple.ets b/ets2panda/test/runtime/ets/first_match/array_and_tuple.ets new file mode 100644 index 0000000000..9a6b55a98e --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/array_and_tuple.ets @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(a: [string, string, string]): string { + return "invoke1"; + } + foo2(a: [number, string, boolean]): string { + return "invoke2"; + } + foo3(a: number[]): string { + return "invoke3"; + } + + overload foo{ foo1, foo2, foo3 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(["abc", "abc", "abc"]), "invoke1"); + arktest.assertEQ(a.foo([123, "abc", true]), "invoke2"); + arktest.assertEQ(a.foo([123, 123, 123]), "invoke3"); + + let param1: [string, string, string] = ["abc", "abc", "abc"]; + let param2: [number, string, boolean] = [123, "abc", true]; + let param3: number[] = [123, 123, 123] + arktest.assertEQ(a.foo(param1), "invoke1"); + arktest.assertEQ(a.foo(param2), "invoke2"); + arktest.assertEQ(a.foo(param3), "invoke3"); +} diff --git a/ets2panda/test/runtime/ets/first_match/ctor_need_fix_bytecode.ets b/ets2panda/test/runtime/ets/first_match/ctor_need_fix_bytecode.ets new file mode 100644 index 0000000000..a089ad0a17 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/ctor_need_fix_bytecode.ets @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} + +class Test { + constructor(a: number) { + this.testString = "invoke1" + } + constructor con1(a: string){ + this.testString = "invoke2" + } + constructor con2(a: A){ + this.testString = "invoke3" + } + + testString = "" + + overload constructor{ con1, con2 } +} + +class Test2 { + constructor con1(a: string){ + this.testString = "invoke4" + } + constructor con2(a: A){ + this.testString = "invoke5" + } + + testString = "" + + overload constructor{ con1, con2 } +} + +function main() { + let var1 = new Test(10); + let var2 = new Test("123"); + let var3 = new Test(new A()); + arktest.assertEQ(var1.testString, "invoke1") + arktest.assertEQ(var2.testString, "invoke2") + arktest.assertEQ(var3.testString, "invoke3") + + let var4 = new Test2("123"); + let var5 = new Test2(new A()) + arktest.assertEQ(var4.testString, "invoke4") + arktest.assertEQ(var5.testString, "invoke5") +} diff --git a/ets2panda/test/runtime/ets/first_match/enum.ets b/ets2panda/test/runtime/ets/first_match/enum.ets new file mode 100644 index 0000000000..6ff320e92c --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/enum.ets @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2025 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. + */ + +enum TestEnum1 { + A = 0, + B = 1, + C = 2, + D = 3, +} + +enum TestEnum2 { + A = "A", + B = "B", + C = "C", + D = "D", +} + +class Test { + foo1(a: TestEnum1): string { + return "invoke1" + } + foo2(a: TestEnum2): string { + return "invoke2" + } + foo3(a: TestEnum1 | TestEnum2): string { + return "invoke3" + } + + overload foo{ foo1, foo2, foo3 } +} + +class Test2 { + foo1(a: string, b: TestEnum1): string { + return "invoke1" + } + foo2(a: number, b: TestEnum2): string { + return "invoke2" + } + foo3(a: string | number, b: TestEnum1 | TestEnum2): string { + return "invoke3" + } + + overload foo{ foo1, foo2, foo3 } +} + +class Test3 { + foo1(a: string): string { + return "invoke1" + } + foo2(a: number): string { + return "invoke2" + } + foo3(a: string | number): string { + return "invoke3" + } + + overload foo{ foo1, foo2, foo3 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(TestEnum1.A), "invoke1"); + arktest.assertEQ(a.foo(TestEnum2.B), "invoke2"); + arktest.assertEQ(a.foo(TestEnum1.A), "invoke1"); + + let b: Test2 = new Test2(); + arktest.assertEQ(b.foo("123", TestEnum1.A), "invoke1"); + arktest.assertEQ(b.foo(123, TestEnum1.A), "invoke3"); + arktest.assertEQ(b.foo("123", TestEnum2.C), "invoke3"); + arktest.assertEQ(b.foo(123, TestEnum2.C), "invoke2"); + + let c: Test3 = new Test3(); + arktest.assertEQ(c.foo(TestEnum1.A), "invoke2"); + arktest.assertEQ(c.foo(TestEnum2.B), "invoke1"); + arktest.assertEQ(c.foo(TestEnum1.A.valueOf()), "invoke2"); + arktest.assertEQ(c.foo(TestEnum2.B.valueOf()), "invoke1"); +} + diff --git a/ets2panda/test/runtime/ets/first_match/enum2.ets b/ets2panda/test/runtime/ets/first_match/enum2.ets new file mode 100644 index 0000000000..424c56ea6c --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/enum2.ets @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2025 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. + */ + +enum MyEnum { + a = 1, +} + +function foo1(a: int): string { + return "invoke1" +} + +function foo2(a: MyEnum): string { + return "invoke2" +} + +overload foo{ foo1, foo2 } + +overload fooo{ foo2, foo1 } + +function main() { + arktest.assertEQ(foo(MyEnum.a), "invoke1") + arktest.assertEQ(fooo(MyEnum.a), "invoke2") +} diff --git a/ets2panda/test/runtime/ets/first_match/function_need_fix_variable.ets b/ets2panda/test/runtime/ets/first_match/function_need_fix_variable.ets new file mode 100644 index 0000000000..049b787496 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/function_need_fix_variable.ets @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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. + */ + +namespace NS { + export function foo3(a: string): string { + return "invoke3" + } +} + +class A { } + +function foo1(a: A): string { + return "invoke1" +} + +function foo2(a: number): string { + return "invoke2" +} + +overload foo{ foo1, foo2 } + +function main() { + arktest.assertEQ(foo(new A()), "invoke1") + arktest.assertEQ(foo(123), "invoke2") + arktest.assertEQ(NS.foo3("123"), "invoke3") +} + diff --git a/ets2panda/test/runtime/ets/first_match/generics.ets b/ets2panda/test/runtime/ets/first_match/generics.ets new file mode 100644 index 0000000000..8175ad3985 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/generics.ets @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(a: T[]): string { + return "invoke1"; + } + foo2(a: string[]): string { + return "invoke2"; + } + foo3(a: Array): string { + return "invoke3"; + } + foo4(a: Array): string { + return "invoke4"; + } + foo5(a: T[][]): string { + return "invoke5"; + } + foo6(a: string[][]): string { + return "invoke6"; + } + + overload foo{ foo1, foo2, foo3, foo4, foo5, foo6 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo([123, 123, 123]), "invoke1"); + arktest.assertEQ(a.foo(new number[5]), "invoke1"); + arktest.assertEQ(a.foo(new Array(2)), "invoke1"); + arktest.assertEQ(a.foo(new number[5][10]), "invoke5"); + + arktest.assertEQ(a.foo(["abc", "abc", "abc"]), "invoke2"); + arktest.assertEQ(a.foo(new string[5]), "invoke2"); + arktest.assertEQ(a.foo(new Array(2)), "invoke2"); + arktest.assertEQ(a.foo(new string[5][10]), "invoke6"); +} diff --git a/ets2panda/test/runtime/ets/first_match/generics_2.ets b/ets2panda/test/runtime/ets/first_match/generics_2.ets new file mode 100644 index 0000000000..d494c08ab4 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/generics_2.ets @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field: string = "A" +} + +class Test { + foo1(a: string): string { + return "invoke1" + } + foo2(a: T): string { + return "invoke2" + } + foo3(a: T1): string { + return "invoke3" + } + foo4(a: T1, b: T2): string { + return "invoke4" + } + + overload foo{ foo1, foo2, foo3, foo4 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(new A()), "invoke2"); + arktest.assertEQ(a.foo(10), "invoke3"); + arktest.assertEQ(a.foo(10, "abc"), "invoke4"); + arktest.assertEQ(a.foo(10), "invoke3"); + arktest.assertEQ(a.foo(10, "abc"), "invoke4"); +} diff --git a/ets2panda/test/runtime/ets/first_match/lambda_infer.ets b/ets2panda/test/runtime/ets/first_match/lambda_infer.ets new file mode 100644 index 0000000000..62842d63ae --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/lambda_infer.ets @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(lambda: () => void): string { + return "invoke1"; + } + foo2(lambda: (p1: string, p2: number) => void): string { + lambda("invoke2", 123456); + return "invoke2"; + } + foo3(lambda: (p1: number, p2: string) => void): string { + lambda(123456, "invoke3"); + return "invoke3"; + } + foo4(lambda: (p1: number, p2: string, p3: boolean) => void) { + lambda(123, "123", true); + return "invoke4"; + } + + overload foo{ foo1, foo2, foo3, foo4 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(() => { }), "invoke1"); + arktest.assertEQ(a.foo((p1: string, p2) => { }), "invoke2"); + arktest.assertEQ(a.foo((p1: number, p2) => { }), "invoke3"); + arktest.assertEQ(a.foo((p1, p2) => { }), "invoke2"); + arktest.assertEQ(a.foo((p1: number, p2, p3) => { }), "invoke4"); + arktest.assertEQ(a.foo((p1, p2, p3) => { }), "invoke4"); +} diff --git a/ets2panda/test/runtime/ets/first_match/lambda_order.ets b/ets2panda/test/runtime/ets/first_match/lambda_order.ets new file mode 100644 index 0000000000..0783b9485e --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/lambda_order.ets @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(lambda: () => void): string { + return "invoke1"; + } + foo2(lambda: (p1: string, p2: number) => void): string { + lambda("invoke2", 123456); + return "invoke2"; + } + foo3(lambda: (p1: number, p2: string) => void): string { + lambda(123456, "invoke3"); + return "invoke3"; + } + foo4(lambda: (p1: number, p2: string, p3: boolean) => void): string { + lambda(123, "123", true); + return "invoke4" + } + + overload foo{ foo1, foo2, foo3, foo4 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo((): void => { }), "invoke1"); + arktest.assertEQ(a.foo((p1: string, p2: number): void => { }), "invoke2"); + arktest.assertEQ(a.foo((p1: number, p2: string): void => { }), "invoke3"); + arktest.assertEQ(a.foo((p1: number, p2: string, p3: boolean): void => { }), "invoke4"); + + let param1 = (): void => { }; + let param2 = (p1: string, p2: number): void => { }; + let param3 = (p1: number, p2: string): void => { }; + let param4 = (p1: number, p2: string, p3: boolean): void => { }; + arktest.assertEQ(a.foo(param1), "invoke1"); + arktest.assertEQ(a.foo(param2), "invoke2"); + arktest.assertEQ(a.foo(param3), "invoke3"); + arktest.assertEQ(a.foo(param4), "invoke4"); +} diff --git a/ets2panda/test/runtime/ets/first_match/lambda_type_alias.ets b/ets2panda/test/runtime/ets/first_match/lambda_type_alias.ets new file mode 100644 index 0000000000..2a1147db22 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/lambda_type_alias.ets @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2025 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. + */ + +type AsyncCallback = (err: T, data: T) => void; +type AsyncCallback2 = (err: string, data: number, data2: number) => void; + +function getBundleInfo1(userId?: number): string { + return "invoke1" +} + +function getBundleInfo2(callback: AsyncCallback): string { + callback(666, 66); + return "invoke2" +} + +function getBundleInfo3(callback: AsyncCallback2): string { + callback("invoke3", 66, 66); + return "invoke3" +} + +overload getBundleInfo{ getBundleInfo1, getBundleInfo2, getBundleInfo3 } + +function main() { + arktest.assertEQ(getBundleInfo((err, data) => { + arktest.assertEQ(err, 666); + arktest.assertEQ(data, 66) + }), "invoke2") + + arktest.assertEQ(getBundleInfo((err: string, data1: number, data2: number) => { + arktest.assertEQ(err, "invoke3"); + arktest.assertEQ(data1, 66); + arktest.assertEQ(data2, 66); + }), "invoke3") +} diff --git a/ets2panda/test/runtime/ets/first_match/namespace.ets b/ets2panda/test/runtime/ets/first_match/namespace.ets new file mode 100644 index 0000000000..7df1fa2c27 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/namespace.ets @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2025 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. + */ + +namespace NS { + export function foo1(a: string): string { + return "invoke1" + }; + export function foo2(a: boolean): string { + return "invoke2" + }; +} + +function foo3(a: number): string { + return "invoke3" +}; + +overload foo{ foo3, NS.foo1, NS.foo2 }; + +function main() { + arktest.assertEQ(foo("123"), "invoke1") + arktest.assertEQ(foo(1), "invoke3") + arktest.assertEQ(foo(true), "invoke2") +} diff --git a/ets2panda/test/runtime/ets/first_match/namespace2.ets b/ets2panda/test/runtime/ets/first_match/namespace2.ets new file mode 100644 index 0000000000..b7c09fe150 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/namespace2.ets @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2025 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. + */ + +namespace NS { + export namespace NS2 { + export function foo1(a: string): string { + return "invoke1" + }; + export namespace NS3 { + export function foo2(a: number): string { + return "invoke2" + }; + } + } + + export function foo3(a: boolean): string { + return "invoke3" + }; +} + +class A { } + +function foo4(a: A): string { + return "invoke4" +}; + +overload foo{ foo4, NS.NS2.foo1, NS.NS2.NS3.foo2, NS.foo3 }; + +function main() { + arktest.assertEQ(foo("aaa"),"invoke1"); + arktest.assertEQ(foo(1),"invoke2"); + arktest.assertEQ(foo(true),"invoke3"); + arktest.assertEQ(foo(new A()),"invoke4"); +} diff --git a/ets2panda/test/runtime/ets/first_match/namespace3.ets b/ets2panda/test/runtime/ets/first_match/namespace3.ets new file mode 100644 index 0000000000..37ad202c81 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/namespace3.ets @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2025 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. + */ + +namespace NS { + export function foo1(a: string): string { + return "invoke1" + }; + export function foo2(a: boolean): string { + return "invoke2" + }; +} + +namespace NS2 { + export function foo3(a: number): string { + return "invoke3" + } +} + +class A { } + +function foo4(a: A): string { + return "invoke4" +}; + +overload foo{ foo4, NS.foo1, NS.foo2, NS2.foo3 }; + +function main() { + arktest.assertEQ(foo("123"), "invoke1") + arktest.assertEQ(foo(true), "invoke2") + arktest.assertEQ(foo(1), "invoke3") + arktest.assertEQ(foo(new A()), "invoke4") +} diff --git a/ets2panda/test/runtime/ets/first_match/objectliteral_optional.ets b/ets2panda/test/runtime/ets/first_match/objectliteral_optional.ets new file mode 100644 index 0000000000..57514500e8 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/objectliteral_optional.ets @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2025 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. + */ + +enum TestEnum{ + Kind1 = 0, + Kind2 = 1, + Kind3 = 2, +} +class A{ + field1:number = 0; + field2:string = "abc" + field3:boolean = true; +} + +class B{ + field1:string = "abc"; + field2?:number = 0; + field3:boolean = true; + field4?:TestEnum; +} + +class C{ + field1:number = 0; + field2?:string = "abc"; + field3?:string = "abc"; + field4:string = "abc" +} + + +class Test{ + foo1(a:A):string{ + return "invoke1"; + } + foo2(a:B):string{ + return "invoke2"; + } + foo3(a:C):string{ + return "invoke3"; + } + + overload foo{foo1,foo2,foo3} +} + +function main(){ + let a:Test = new Test(); + arktest.assertEQ(a.foo({field1:1,field2:"abc",field3:true}),"invoke1"); + + arktest.assertEQ(a.foo({field1:"abc",field2:0,field3:true,field4:TestEnum.Kind1}),"invoke2"); + arktest.assertEQ(a.foo({field1:"abc",field3:true,field4:TestEnum.Kind1}),"invoke2"); + arktest.assertEQ(a.foo({field1:"abc",field2:0,field3:true}),"invoke2"); + arktest.assertEQ(a.foo({field1:"abc",field3:true}),"invoke2"); + + arktest.assertEQ(a.foo({field1:1,field2:"abc",field3:"abc",field4:"abc"}),"invoke3"); + arktest.assertEQ(a.foo({field1:1,field2:"abc",field4:"abc"}),"invoke3"); + arktest.assertEQ(a.foo({field1:1,field3:"abc",field4:"abc"}),"invoke3"); + arktest.assertEQ(a.foo({field1:1,field4:"abc"}),"invoke3"); +} diff --git a/ets2panda/test/runtime/ets/first_match/objectliteral_order.ets b/ets2panda/test/runtime/ets/first_match/objectliteral_order.ets new file mode 100644 index 0000000000..316970ab3b --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/objectliteral_order.ets @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field: number = 0; +} + +class B { + field: string = "abc"; +} + +class C { + field1: number = 0; + field2: string = "abc"; +} + +class Test { + foo1(a: A): string { + return "invoke1"; + } + foo2(a: B): string { + return "invoke2"; + } + foo3(a: C): string { + return "invoke3"; + } + + overload foo{ foo1, foo2, foo3 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo({ field: 1 }), "invoke1"); + arktest.assertEQ(a.foo({ field: "abc" }), "invoke2"); + arktest.assertEQ(a.foo({ field1: 1, field2: "abc" }), "invoke3"); +} diff --git a/ets2panda/test/runtime/ets/first_match/objectliteral_same.ets b/ets2panda/test/runtime/ets/first_match/objectliteral_same.ets new file mode 100644 index 0000000000..11d2198e46 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/objectliteral_same.ets @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field1: number = 0; + field2: string = "abc" + field3: boolean = true; +} + +class B { + field1: number = 0; + field2: string = "abc" + field3: boolean = true; +} + +class C { + field1: number = 0; + field2: string = "abc" + field3: boolean = true; +} + + +class Test { + foo1(a: A): string { + return "invoke1"; + } + foo2(a: B): string { + return "invoke2"; + } + foo3(a: C): string { + return "invoke3"; + } + + overload foo{ foo1, foo2, foo3 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo({ field1: 1, field2: "abc", field3: true }), "invoke1"); + arktest.assertEQ(a.foo({ field1: 1, field2: "abc", field3: false }), "invoke1"); +} diff --git a/ets2panda/test/runtime/ets/first_match/optinal_parameter.ets b/ets2panda/test/runtime/ets/first_match/optinal_parameter.ets new file mode 100644 index 0000000000..f1d5da2864 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/optinal_parameter.ets @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field: string = "A" +} +class B { + field: string = "B" +} + +class Test { + foo1(a?: A,): string { + return "invoke1"; + } + foo2(a?: A, b?: B): string { + return "invoke2"; + } + foo3(a?: B, b?: A): string { + return "invoke3"; + } + foo4(a?: B, b?: B): string { + return "invoke4"; + } + + overload foo{ foo1, foo2, foo3, foo4 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(new A()), "invoke1"); + arktest.assertEQ(a.foo(new B()), "invoke3"); + arktest.assertEQ(a.foo(new A(), new B()), "invoke2"); + arktest.assertEQ(a.foo(new B(), new A()), "invoke3"); + arktest.assertEQ(a.foo(new B(), new B()), "invoke4"); +} diff --git a/ets2panda/test/runtime/ets/first_match/override_class.ets b/ets2panda/test/runtime/ets/first_match/override_class.ets new file mode 100644 index 0000000000..aaec7eb4e5 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/override_class.ets @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + overload foo { fooNumber, fooString } + fooNumber(a: number):string{ + return "invoke1"; + } + fooString(a: string):string{ + return "invoke2"; + } +} + +class Sub1 extends Base { + override fooNumber(a: number): string { + return "invoke3"; + } +} + +class Sub2 extends Base { + fooInt(a: int): string { + return "invoke4"; + } + overload foo{ fooInt, fooNumber, fooString } +} + +function main() { + let a = new Sub1(); + arktest.assertEQ(a.fooNumber(1), "invoke3") + arktest.assertEQ(a.foo(1), "invoke3") + arktest.assertEQ(a.foo("abc"), "invoke2") + + let b = new Sub2(); + arktest.assertEQ(b.foo(1), "invoke4") + arktest.assertEQ(b.foo("abc"), "invoke2") +} diff --git a/ets2panda/test/runtime/ets/first_match/override_interface.ets b/ets2panda/test/runtime/ets/first_match/override_interface.ets new file mode 100644 index 0000000000..8bfbb15df8 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/override_interface.ets @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2025 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. + */ + +interface Base { + overload foo { fooNumber, fooString } + + fooNumber(a: number):string + fooString(a: string):string +} + +class Sub1 implements Base { + fooNumber(a: number): string { + return "invoke1" + } + fooString(a: string): string { + return "invoke2" + } +} + +class Sub2 implements Base { + fooInt(a: int): string { + return "invoke1" + } + fooNumber(a: number): string { + return "invoke2" + } + fooString(a: string): string { + return "invoke3" + } + + overload foo{ fooInt, fooNumber, fooString } +} + +function main() { + let a = new Sub1(); + arktest.assertEQ(a.fooNumber(1), "invoke1"); + arktest.assertEQ(a.foo(1), "invoke1"); + arktest.assertEQ(a.foo("abc"), "invoke2"); + + let b = new Sub2(); + arktest.assertEQ(b.foo(1), "invoke1"); + arktest.assertEQ(b.foo("abc"), "invoke3"); +} diff --git a/ets2panda/test/runtime/ets/first_match/primitive.ets b/ets2panda/test/runtime/ets/first_match/primitive.ets new file mode 100644 index 0000000000..fdb2a3acc9 --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/primitive.ets @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2025 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. + */ + +class Test { + foo1(a: byte): string { return "invoke1" } + foo2(a: int): string { return "invoke2" } + foo3(a: float): string { return "invoke3" } + foo4(a: number): string { return "invoke4" } + foo5(a: char): string { return "invoke5" } + foo6(a: string): string { return "invoke6" } + foo7(a: Byte): string { return "invoke7" } + foo8(a: Int): string { return "invoke8" } + foo9(a: Number): string { return "invoke9" } + foo10(a: Float): string { return "invoke10" } + + overload foo{ foo1, foo2, foo3, foo4, foo5, foo6, foo7, foo8, foo9, foo10 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(1), "invoke2") + arktest.assertEQ(a.foo(1 as byte), "invoke1") + arktest.assertEQ(a.foo(1 as int), "invoke2") + arktest.assertEQ(a.foo(1 as number), "invoke4") + arktest.assertEQ(a.foo(1.0), "invoke4") + arktest.assertEQ(a.foo(1.0 as float), "invoke3") + arktest.assertEQ(a.foo('a'), "invoke6") + arktest.assertEQ(a.foo("abcd"), "invoke6") + + let param1: Int = 1; + let param2: Number = 1; + let param3: Float = 1; + arktest.assertEQ(a.foo(param1), "invoke2") + arktest.assertEQ(a.foo(param2), "invoke4") + arktest.assertEQ(a.foo(param3), "invoke3") +} diff --git a/ets2panda/test/runtime/ets/first_match/rest_parameter.ets b/ets2panda/test/runtime/ets/first_match/rest_parameter.ets new file mode 100644 index 0000000000..1f25bf060d --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/rest_parameter.ets @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field: string = "A" +} +class B { + field: string = "B" +} + +class Test { + foo1(a: string): string { + return "invoke1" + } + foo2(a: A, b: B, ...args: string[]): string { + return "invoke2" + } + foo3(a: B, ...args: string[]): string { + return "invoke3" + } + + overload foo{ foo1, foo2, foo3 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo("abc"), "invoke1"); + + let restparam1: string[] = ["abc", "abc"] + arktest.assertEQ(a.foo(new A(), new B()), "invoke2"); + arktest.assertEQ(a.foo(new A(), new B(), "abc"), "invoke2"); + arktest.assertEQ(a.foo(new A(), new B(), "abc", "abc", "abc"), "invoke2"); + arktest.assertEQ(a.foo(new A(), new B(), ...restparam1), "invoke2"); + + let restparam2: string[] = ["abc", "abc"] + arktest.assertEQ(a.foo(new B()), "invoke3"); + arktest.assertEQ(a.foo(new B(), "abc"), "invoke3"); + arktest.assertEQ(a.foo(new B(), "abc", "abc", "abc"), "invoke3"); + arktest.assertEQ(a.foo(new B(), ...restparam1), "invoke3"); +} diff --git a/ets2panda/test/runtime/ets/first_match/static_and_nonstatic.ets b/ets2panda/test/runtime/ets/first_match/static_and_nonstatic.ets new file mode 100644 index 0000000000..0d5661146a --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/static_and_nonstatic.ets @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + static foo1(a: number): string { + return "invoke1" + }; + static foo2(a: string): string { + return "invoke2" + }; + + static overload foo{ foo1, foo2 } + + foo3(a: number): string { + return "invoke3" + }; + foo4(a: string): string { + return "invoke4" + }; + + overload foo{ foo3, foo4 } +} + +function main() { + let a = new A(); + arktest.assertEQ(a.foo(1), "invoke3") + arktest.assertEQ(a.foo("aaa"), "invoke4") + arktest.assertEQ(A.foo(1), "invoke1") + arktest.assertEQ(A.foo("aaa"), "invoke2") +} diff --git a/ets2panda/test/runtime/ets/first_match/stringliteral.ets b/ets2panda/test/runtime/ets/first_match/stringliteral.ets new file mode 100644 index 0000000000..2f354314af --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/stringliteral.ets @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2025 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. + */ + +function on1(type: "click", callback: () => void): string { + return "invoke1" +} + +function on2(type: "gestrue", callback: () => void): string { + return "invoke2" +} + +function on3(type: "Roll", callback: (param1: number) => void): string { + return "invoke3" +} + +overload on{ on1, on2, on3 } + +function main() { + arktest.assertEQ(on("click", () => { }), "invoke1") + arktest.assertEQ(on("gestrue", () => { }), "invoke2") + arktest.assertEQ(on("Roll", (a: number) => { }), "invoke3") +} + diff --git a/ets2panda/test/runtime/ets/first_match/trailing_lambda.ets b/ets2panda/test/runtime/ets/first_match/trailing_lambda.ets new file mode 100644 index 0000000000..74e0a50c3c --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/trailing_lambda.ets @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { } +class B { } + +class Test { + foo1(a: A, lambda1: () => void): string { + lambda1() + return "invoke1"; + } + foo2(a: A, b: B, lambda1: (a: number) => void): string { + lambda1(1) + return "invoke2"; + } + foo3(a: A, b: B, lambda1: () => void): string { + lambda1() + return "invoke3"; + } + foo4(a: B, b: A, lambda1: () => void): string { + lambda1() + return "invoke4"; + } + + overload foo{ foo1, foo2, foo3, foo4 } +} + +function main() { + let a: Test = new Test(); + + arktest.assertEQ(a.foo(new A(), () => { }), "invoke1") + arktest.assertEQ(a.foo(new A()){ return; }, "invoke1") + + arktest.assertEQ(a.foo(new A(), new B(), (a: number) => { }), "invoke2") + + arktest.assertEQ(a.foo(new A(), new B(), () => { }), "invoke2") + arktest.assertEQ(a.foo(new A(), new B()){ return; }, "invoke2") + + arktest.assertEQ(a.foo(new B(), new A(), () => { }), "invoke4") + arktest.assertEQ(a.foo(new B(), new A()){ return; }, "invoke4") +} diff --git a/ets2panda/test/runtime/ets/first_match/union.ets b/ets2panda/test/runtime/ets/first_match/union.ets new file mode 100644 index 0000000000..34ee5b7f0e --- /dev/null +++ b/ets2panda/test/runtime/ets/first_match/union.ets @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field: string = "A" +} +class B { + field: string = "B" +} + +class Test { + foo1(a: string): string { + return "invoke1"; + } + foo2(a: A | number): string { + return "invoke2"; + } + foo3(a: A | B | string | number): string { + return "invoke3"; + } + + overload foo{ foo1, foo2, foo3 } +} + +function main() { + let a: Test = new Test(); + arktest.assertEQ(a.foo(new A()), "invoke2"); + arktest.assertEQ(a.foo(new B()), "invoke3"); + arktest.assertEQ(a.foo("abc"), "invoke1"); + arktest.assertEQ(a.foo(123), "invoke2"); +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/15445.ets b/ets2panda/test/runtime/ets/overload_declaration/15445.ets new file mode 100644 index 0000000000..04863ae70f --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/15445.ets @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + public static foo1(fn: (a1: A1) => void, arg: A1): void { + fn(arg) + } + public static foo2(fn: (a1: A1, a2: A2) => void, arg1: A1, arg2: A2): void { + fn(arg1, arg2) + } + static overload foo{ foo1, foo2 } +} + +function t1(s: String): void { +} + +function t2(s: String, n: int): void { +} + +function main(): int { + A.foo(t1, "lll"); + A.foo(t2, "llll", 1) + return 0 +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/15502.ets b/ets2panda/test/runtime/ets/overload_declaration/15502.ets new file mode 100644 index 0000000000..05439ef6ee --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/15502.ets @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + public static foo1(fn: (a: A1) => void, arg: A1): void { + fn(arg) + } + public static foo2(fn: (a1: A1, a2: A2) => void, arg1: A1, arg2: A2): void { + fn(arg1, arg2) + } + static overload foo{ foo1, foo2 } +} + +function t1(s: String): void { +} + +function t2(s: String, n: int): void { +} + +function main(): int { + A.foo(t1, "lll"); + A.foo(t2, "llll", 1) + return 0 +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/Enum2.ets b/ets2panda/test/runtime/ets/overload_declaration/Enum2.ets new file mode 100644 index 0000000000..9d25d2fc0a --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/Enum2.ets @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2025 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. + */ + +enum Color { Red, Green, Blue } + +class ColorEnumDelegate { + private static values_: Color[] = [Color.Red, Color.Green, Color.Blue]; + private static names_: String[] = ["Red", "Green", "Blue"]; + + public static values(): Color[] { return ColorEnumDelegate.values_; } + + public static ordinal(x: Color): int { return x as int; } + + public static toString(x: Color): String { return ColorEnumDelegate.names_[x as int]; } + + public static valueOf1(name: String): Color { + for (let i = 0; i < ColorEnumDelegate.values_.length; i++) { + if (ColorEnumDelegate.names_[i] == name) { return ColorEnumDelegate.values_[i]; } + } + + arktest.assertTrue(false, "No enum constant Color") + return Color.Red; + } + + public static valueOf2(ordinal: int): Color { + if (0 <= ordinal && ordinal < ColorEnumDelegate.values_.length) { + return ColorEnumDelegate.values_[ordinal]; + } + + arktest.assertTrue(false, "No enum constant Color") + return Color.Red; + } + + static overload valueOf{ valueOf1, valueOf2 } +} + +function main(): void { + let red: Color = Color.Red; + arktest.assertEQ(ColorEnumDelegate.toString(red), "Red") + + arktest.assertEQ(ColorEnumDelegate.ordinal(red), 0) + arktest.assertEQ(ColorEnumDelegate.ordinal(Color.Green), 1) + + arktest.assertEQ(ColorEnumDelegate.valueOf(2), Color.Blue) + arktest.assertEQ(ColorEnumDelegate.valueOf(ColorEnumDelegate.ordinal(Color.Red)), red) + + arktest.assertEQ(ColorEnumDelegate.valueOf("Green"), Color.Green) + arktest.assertEQ(ColorEnumDelegate.valueOf(ColorEnumDelegate.toString(Color.Blue)), Color.Blue) +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature01.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature01.ets new file mode 100644 index 0000000000..73ef400a6b --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature01.ets @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5), 5); +} + +function foo2(a: int, b: int = 10): int { + return a + b; +} + +function foo1(a: int): int { + return a; +} + +overload foo{ foo1, foo2 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature02.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature02.ets new file mode 100644 index 0000000000..e0a6e440fe --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature02.ets @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5), 5); +} + +function foo2(a: int, b?: int): int { + return a + 2; +} + +function foo1(a: int): int { + return a; +} + +overload foo{ foo1, foo2 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature03.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature03.ets new file mode 100644 index 0000000000..fe270edcf8 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature03.ets @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5), 5); +} + +function foo2(a: int, ...b: int[]): int { + return a + 2; +} + +function foo1(a: int): int { + return a; +} + +overload foo{ foo1, foo2 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature04.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature04.ets new file mode 100644 index 0000000000..54029d15cc --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature04.ets @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5, 2), 7); +} + +function foo2(a: int, ...b: int[]): int { + return 0; +} + +function foo1(a: int, b: int): int { + return a + b; +} + +overload foo{ foo1, foo2 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature05.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature05.ets new file mode 100644 index 0000000000..1fa99e6569 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature05.ets @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5, 2), "aaaa"); +} + +function foo1(a: int, b: int): string { + return "aaaa"; +} + +function foo3(a: int, ...b: int[]): string { + return "bbbb"; +} + +function foo2(a: int, b: int, c?: int): string { + return "cccc"; +} + +overload foo{ foo1, foo2, foo3 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature06.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature06.ets new file mode 100644 index 0000000000..ff27d701d5 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature06.ets @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5, 2), "aaaa"); +} + +function foo1(a: int, b: int): string { + return "aaaa"; +} + +function foo3(a: int, ...b: int[]): string { + return "bbbb"; +} + +function foo2(a: int, b: int, c: int = 10): string { + return "cccc"; +} + +overload foo{ foo1, foo2, foo3 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature07.ets b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature07.ets new file mode 100644 index 0000000000..da6662e4b3 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FirstMatchSignature07.ets @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo("1"), 3); +} + +class A { } +class B { } + +function foo2(x: string, y?: A) { + return 1 +} +function foo3(x: string, y?: B) { + return 2 +} +function foo1(x: string) { + return 3 +} + +overload foo{ foo1, foo2, foo3 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/FixFunctionCall.ets b/ets2panda/test/runtime/ets/overload_declaration/FixFunctionCall.ets new file mode 100644 index 0000000000..1594345abf --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FixFunctionCall.ets @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2025 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. + */ + +export type AsyncCallback = (err: T, data: T) => void; + +function getBundleInfo1(userId?: number): void { } +function getBundleInfo2(callback: AsyncCallback): void { + callback(666, 66); +} +overload getBundleInfo{ getBundleInfo1, getBundleInfo2 } + +getBundleInfo((err, data) => { + arktest.assertEQ(err, 666); + arktest.assertEQ(data, 66) +}); diff --git a/ets2panda/test/runtime/ets/overload_declaration/FunctionOverload.ets b/ets2panda/test/runtime/ets/overload_declaration/FunctionOverload.ets new file mode 100644 index 0000000000..84ad4d8400 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/FunctionOverload.ets @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2025 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. + */ + +class Overload { + public static func1(): string { + return "zero"; + } + + public static func2(a: number): string { + return "one"; + } + + public static func3(a: number, b: number): string { + return "two"; + } + + public static func4(...args: number[]): string { + return "variadic"; + } + + static overload func{ func1, func2, func3, func4 } +} + +function main(): void { + arktest.assertEQ(Overload.func(), "zero") + arktest.assertEQ(Overload.func(1), "one") + arktest.assertEQ(Overload.func(1, 2), "two") + arktest.assertEQ(Overload.func(1, 2, 3), "variadic") + + let arr: number[] = [1, 2]; + arktest.assertEQ(Overload.func(...arr), "variadic") +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/InterfacePrivateMethod2.ets b/ets2panda/test/runtime/ets/overload_declaration/InterfacePrivateMethod2.ets new file mode 100644 index 0000000000..7a415f960b --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/InterfacePrivateMethod2.ets @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2025 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. + */ + +interface Vehicle { + getHorsePower31(rpm: int, trq: int): int{ + return (rpm * trq) / 5252; + } + + getPwrIndex1(trq: int): int{ + return this.getHorsePower3(5252, trq); + } + + getHorsePower32(rpm: int): int{ + return rpm; + } + + getPwrIndex2(trq: int, second: int): int{ + return this.getHorsePower3(trq + second); + } + + overload getHorsePower3{ getHorsePower31, getHorsePower32 } + + overload getPwrIndex{ getPwrIndex1, getPwrIndex2 } +} + +class Car implements Vehicle { } + +function main(): void { + arktest.assertEQ(new Car().getPwrIndex(1), 1) + arktest.assertEQ(new Car().getPwrIndex(1, 1), 2) +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/RestTuple4.ets b/ets2panda/test/runtime/ets/overload_declaration/RestTuple4.ets new file mode 100644 index 0000000000..b6cc175535 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/RestTuple4.ets @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + public field: number + constructor constructor2(...numbers: [number, number, number]) { + this.field = numbers[0] + numbers[1] + numbers[2] + } + + constructor constructor1(a: int, ...numbers: [number, number, number]) { + this.field = a + numbers[0] + numbers[1] + numbers[2] + } + + overload constructor{ constructor1, constructor2 } +} + +function main() { + let tuple: [number, number, number] = [30, 40, 50] + + let res: A = new A(10, 20, 30) + let res2: A = new A(10, 20, 30, 40) + + let res3: A = new A(...tuple) + let res4: A = new A(10, ...tuple) + + let res5: A = new A(...([30, 40, 50] as [number, number, number])) + let res6: A = new A(10, ...([30, 40, 50] as [number, number, number])) + + arktest.assertEQ(res.field, 60) + arktest.assertEQ(res2.field, 100) + arktest.assertEQ(res3.field, 120) + arktest.assertEQ(res4.field, 130) + arktest.assertEQ(res5.field, 120) + arktest.assertEQ(res6.field, 130) +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/RestTuple8.ets b/ets2panda/test/runtime/ets/overload_declaration/RestTuple8.ets new file mode 100644 index 0000000000..5a33c0f26e --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/RestTuple8.ets @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { } +class B { } + +class C { + public field: boolean + + constructor constructor2(...p: [A, B]) { + this.field = p[0] == p[1] + } + + constructor constructor1(a: int, ...p: [A, B]) { + this.field = p[0] == p[1] + } + + overload constructor{ constructor1, constructor2 } +} + +function main() { + let a1: [A, B] = [new A, new B] + + arktest.assertTrue((new C(...a1)).field == false) + arktest.assertTrue((new C(22, ...a1)).field == false) + + arktest.assertTrue((new C(...[new A, new B])).field == false) + arktest.assertTrue((new C(22, ...[new A, new B])).field == false) + + arktest.assertTrue((new C(...[new A, new B] as [A, B])).field == false) + arktest.assertTrue((new C(22, ...[new A, new B] as [A, B])).field == false) + + arktest.assertTrue((new C(new A, new B)).field == false) + arktest.assertTrue((new C(22, new A, new B)).field == false) +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/SmartCast_03.ets b/ets2panda/test/runtime/ets/overload_declaration/SmartCast_03.ets new file mode 100644 index 0000000000..7077075c1a --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/SmartCast_03.ets @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2025 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. + */ + +class C { + constructor constructor1() { } + + constructor constructor2(a: int) { + this.x = a; + } + + overload constructor{ constructor1, constructor2 } + + bar(): string { + return "Class C"; + } + + baz(): int { + return this.x; + } + + private x: int = 7; +} + +function foo(c: Object | null | undefined): string { + if (c instanceof string && (c.length == 11 || c == "Test")) { + c = "Case 1"; + } else if (c instanceof C && c.baz() == 7) { + arktest.assertEQ(c.bar(), "Class C") + c = "Case 2"; + } else if (c instanceof Int && c >= 0) { + arktest.assertTrue(c >= 0) + c = "Case 3"; + } else if (c instanceof null) { + arktest.assertEQ(c, null) + c = "Case 4"; + } else { + c = "Case 5"; + } + + arktest.assertEQ(c.length, 6) + return c; +} + +function main(): void { + arktest.assertEQ(foo("Test string"), "Case 1") + arktest.assertEQ(foo("Test"), "Case 1") + arktest.assertEQ(foo("Test string 2"), "Case 5") + arktest.assertEQ(foo("test"), "Case 5") + + arktest.assertEQ(foo(new Int(5)), "Case 3") + arktest.assertEQ(foo(new Int(0)), "Case 3") + arktest.assertEQ(foo(new Int(-5)), "Case 5") + + arktest.assertEQ(foo(new C(7)), "Case 2") + arktest.assertEQ(foo(new C()), "Case 2") + arktest.assertEQ(foo(new C(17)), "Case 5") + + arktest.assertEQ(foo(null), "Case 4") + + arktest.assertEQ(foo(undefined), "Case 5") + arktest.assertEQ(foo(new Number(3.0)), "Case 5") +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/async-func-overload-and-type-infer.ets b/ets2panda/test/runtime/ets/overload_declaration/async-func-overload-and-type-infer.ets new file mode 100644 index 0000000000..0b99a3f81d --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/async-func-overload-and-type-infer.ets @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2025 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. + */ + +async function multipleReturns2(flag: boolean, foo: int) { + if (flag) { + return foo; + } + + return "string1" +} + + +async function multipleReturns1(flag: boolean): Promise { + if (flag) { + return 2; + } + + return "string2" +} + +async overload multipleReturns{ multipleReturns1, multipleReturns2 } + +function main() { + let a: int | string = await multipleReturns(true, 42); + let b: int | string = await multipleReturns(false); + + arktest.assertEQ(a, 42) + arktest.assertEQ(b, "string2") +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/async_method_with_same_name02.ets b/ets2panda/test/runtime/ets/overload_declaration/async_method_with_same_name02.ets new file mode 100644 index 0000000000..fd075cefcb --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/async_method_with_same_name02.ets @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + static async getData1() { + return "I'm a static method1 with name 'getData'"; + } + static async getData2(s: string) { + return s; + } + static async overload getData{ getData1, getData2 } +} + +function main() { + let res1: string = await A.getData() + let res2: string = await A.getData("I'm a static method2 with name 'getData'") + arktest.assertEQ(res1, "I'm a static method1 with name 'getData'") + arktest.assertEQ(res2, "I'm a static method2 with name 'getData'") +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/conditionalExpressionLUB.ets b/ets2panda/test/runtime/ets/overload_declaration/conditionalExpressionLUB.ets new file mode 100644 index 0000000000..d0487c8f89 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/conditionalExpressionLUB.ets @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2025 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. + */ + +interface I { } + +class A { } +class B extends A implements I { } +final class C extends A implements I { } +final class D extends A { } +final class F extends B { } + +function foo6(p: Object): int { + return 1; +} + +function foo5(p: A): int { + return 2; +} + +function foo4(p: B): int { + return 3; +} + +function foo3(p: C): int { + return 4; +} + +function foo2(p: D): int { + return 5; +} + +function foo1(p: F): int { + return 6; +} + +overload foo{ foo1, foo2, foo3, foo4, foo5, foo6 } + +function getTrue(): boolean { + return true +} + +// #15276 foo(Object|null) and foo(Object) overloads +function foo7(p: Object | null): int { + return 7; +} + +function main(): void { + sameTypeLUB(); + objectLUB(); + forkSubtypeLUB(); +} + +function sameTypeLUB(): void { + let a: A = new A(); + let b: A = new A(); + let c = getTrue() ? a : b; + arktest.assertEQ(foo(c), 2) +} + +function objectLUB(): void { + let a: A = new A(); + let b: Int = 2; + let c = getTrue() ? a : b; + arktest.assertEQ(foo(c), 1) + + let arr: Int[] | null = null; + let d = getTrue() ? a : arr; + arktest.assertEQ(foo7(d), 7) +} + +function forkSubtypeLUB(): void { + let a: F = new F(); + let b: D = new D(); + let c = getTrue() ? a : b; + arktest.assertEQ(foo(c), 2) + let d: A = new A(); + let e = getTrue() ? a : b; + arktest.assertEQ(foo(e), 2) + let f: B = new B(); + let g = getTrue() ? a : f; + arktest.assertEQ(foo(g), 3) +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/constructor-issue.ets b/ets2panda/test/runtime/ets/overload_declaration/constructor-issue.ets new file mode 100644 index 0000000000..88efbb6747 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/constructor-issue.ets @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + field: int = 5 + + constructor constructor1(arg: boolean) { + } + + constructor constructor2(arg?: int) { + if (arg == undefined) { + this.field += 20 + } else { + this.field += arg; + return; // Return statement is necessary to reproduce stack overflow and invalid constructor generation issue. + } + } + + overload constructor{ constructor1, constructor2 } +} + +class B { + field: int = 5; + + constructor constructor2(arg: boolean) { + } + + constructor constructor3(arg: int) { + this.field += arg; + return; // Return statement is necessary to reproduce stack overflow issue. + } + + constructor constructor1() { + this(15); + this.field += 30; + } + + overload constructor{ constructor1, constructor2, constructor3 } +} + +function main(): void { + arktest.assertEQ(new A(true).field, 5); // field = 5 + arktest.assertEQ(new A(10).field, 15); // field = 5 + 10 + arktest.assertEQ(new A().field, 25); // field = 5 + 20 + + arktest.assertEQ(new B(true).field, 5); // field = 5 + arktest.assertEQ(new B(20).field, 25); // field = 5 + 20 + arktest.assertEQ(new B().field, 50); // field = 5 + 15 + 30 +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/constructor_overload_sig_with_ref_type.ets b/ets2panda/test/runtime/ets/overload_declaration/constructor_overload_sig_with_ref_type.ets new file mode 100644 index 0000000000..30a8088418 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/constructor_overload_sig_with_ref_type.ets @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{ + a:Int = 1 + constructor constructor1(){} + constructor constructor2(a:Int){} + overload constructor{ constructor1, constructor2 } +} + +class B{ + a:Number = 1 + constructor(){} + constructor constructor1(a:Number){} + overload constructor{ constructor1 } +} + +class C{ + a:String = "1" + constructor constructor1(){} + constructor constructor2(a:String){} + overload constructor{ constructor1, constructor2 } +} + +function main() : void { + let a = new A(5); + let b = new B(5); + let c = new C("5"); +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/default_parameter1.ets b/ets2panda/test/runtime/ets/overload_declaration/default_parameter1.ets new file mode 100644 index 0000000000..73ef400a6b --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/default_parameter1.ets @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ + +function main(): void { + arktest.assertEQ(foo(5), 5); +} + +function foo2(a: int, b: int = 10): int { + return a + b; +} + +function foo1(a: int): int { + return a; +} + +overload foo{ foo1, foo2 } diff --git a/ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_2.ets b/ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_2.ets new file mode 100644 index 0000000000..4a89994fc9 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_2.ets @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2025 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. + */ + +function foo1(...x: FixedArray) { + return 1; +} + +function foo2(...x: FixedArray) { + return 2; +} + +overload foo{ foo1, foo2 } + +arktest.assertEQ(foo("bar"), 1) +arktest.assertEQ(foo(1), 2) diff --git a/ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_3.ets b/ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_3.ets new file mode 100644 index 0000000000..4026b56634 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/first_match_method_with_rest_param_3.ets @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 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. + */ + +type B = Object | null; +function foo2(...b : B[]) { return 1; } +function foo1(str: String) { return 2; } +overload foo{ foo1, foo2 } + +arktest.assertEQ(foo(new String()), 2) diff --git a/ets2panda/test/runtime/ets/overload_declaration/generic-set.ets b/ets2panda/test/runtime/ets/overload_declaration/generic-set.ets new file mode 100644 index 0000000000..d701efae93 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/generic-set.ets @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2025 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. + */ + +interface MyStack { + getTop(): Item | null + pop(): Item | null + push(item: Item): void + isEmpty(): boolean + size(): int +} + +class MyArrayStack implements MyStack { + private container: (Item | undefined)[]; + private top: int = -1; + private readonly DEFAULT_SIZE: int = 100; + constructor constructor1() { + let x = new Object(); + this.container = new (Item | undefined)[this.DEFAULT_SIZE]; + this.top = -1; + } + + constructor constructor2(size: int) { + this.container = new (Item | undefined)[size]; + } + + overload constructor{ constructor1, constructor2 } + override getTop(): Item | null { + if (this.top == -1) { + return null; + } + return this.container[this.top]!; + } + + override pop(): Item | null { + if (this.top == -1) { + return null; + } + return this.container[this.top--]!; + } + + override push(item: Item): void { + this.container[++this.top] = item; + } + + override isEmpty(): boolean { + return (this.top == -1); + } + + override size(): int { + return (this.top + 1); + } +} + +function main(): void { + let stack1: MyArrayStack; + stack1 = new MyArrayStack(); + arktest.assertEQ(stack1.isEmpty(), true) + arktest.assertEQ(stack1.size(), 0) + + stack1.push(new Int(10)); + arktest.assertEQ(stack1.isEmpty(), false) + arktest.assertEQ(stack1.size(), 1) + arktest.assertEQ((stack1.getTop() as Int), 10) + + stack1.push(new Int(20)); + stack1.push(new Int(30)); + arktest.assertEQ(stack1.isEmpty(), false) + arktest.assertEQ(stack1.size(), 3) + arktest.assertEQ((stack1.getTop() as Int), 30) + + arktest.assertEQ((stack1.pop() as Int), 30) + arktest.assertEQ(stack1.size(), 2) + arktest.assertEQ((stack1.pop() as Int), 20) + arktest.assertEQ(stack1.size(), 1) + arktest.assertEQ((stack1.pop() as Int), 10) + arktest.assertEQ(stack1.size(), 0) + arktest.assertEQ(stack1.isEmpty(), true) + + arktest.assertEQ(stack1.getTop(), null) + arktest.assertEQ(stack1.pop(), null) + arktest.assertEQ(stack1.size(), 0) + arktest.assertEQ(stack1.isEmpty(), true) + +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/keyword_get_set_as_identfier2.ets b/ets2panda/test/runtime/ets/overload_declaration/keyword_get_set_as_identfier2.ets new file mode 100644 index 0000000000..e3e07aee1f --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/keyword_get_set_as_identfier2.ets @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2025 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. + */ + +export class set { + constructor constructor1() { } + constructor constructor2(a: int) { }; + overload constructor{ constructor1, constructor2 } + get set(): int { return 1; } + $_get(index: number): set { return new set } + $_set(index: number, value: set) { } +} + +let get: set +get = new set(); + +new + set(1) + +get[get.set] = get[0] diff --git a/ets2panda/test/runtime/ets/overload_declaration/notNull.ets b/ets2panda/test/runtime/ets/overload_declaration/notNull.ets new file mode 100644 index 0000000000..837a42a528 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/notNull.ets @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2025 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. + */ + +function main() { + testLocalIdentifier() + testArgument() + testCallExpression() + testNPE() + testFieldAccess() + testFieldAccess2() +} + +function typeOf1(i: Int): int { + return 1; +} + +function typeOf2(o: Object): int { + return -1; +} + +overload typeOf{ typeOf1, typeOf2 } + +function dummy(): Int | null { + return 5; +} + +function testLocalIdentifier(): void { + let a: Int | null = dummy(); + let b = a!; + + arktest.assertEQ(typeOf(b), 1, "b must be type Int") + arktest.assertEQ(b, 5, "b must be 5") + + let c = b + a! * 7; + + arktest.assertEQ(c, 40, "c should be 40") + + arktest.assertEQ(a!, (a)!) +} + +function bar(arg: Int | null): Int { + return arg!; +} + +function testArgument(): void { + let a: Int | null = 7; + let b = bar(a); + + arktest.assertEQ(typeOf(b), 1, "b must be type Int") + arktest.assertEQ(b, 7) +} + +function foo(): Double | null { + return new Double(3.1415); +} + +class Foo { + foo(): Float | null { + return Float.DELTA; + } +} + +function testCallExpression() { + let d = foo()! + + arktest.assertTrue(d instanceof Double, "d must be type Double") + arktest.assertEQ(d, 3.1415, "d must be 3.1415") + + let sd = foo()!.toString() + + arktest.assertTrue("3.1415".equals(sd), "s must be '3.1415'") + + let f = new Foo().foo()! + + arktest.assertTrue(f instanceof Float, "f must be type Float") + arktest.assertEQ(f, Float.DELTA, "f must be Float.DELTA") +} + +function baz(): Byte | null { + return null; +} + +function aux(): Object | null { + return null; +} + +function testNPE(): void { + let o: Object | null = aux(); + let npe_caught = false; + + try { + (o as Object | null)!; + arktest.assertTrue(false, "this must not be executed") + } catch (ex: NullPointerError) { + npe_caught = true; + } + + arktest.assertTrue(npe_caught, "NPE must be caught") + + try { + baz()!; + arktest.assertTrue(false, "this must not be executed") + } catch (ex: NullPointerError) { + npe_caught = true; + } + + arktest.assertTrue(npe_caught, "NPE must be caught") +} + +class A { + public static c: Char | null = c'C'; + public d: Char | null = c'D' +} + +class B { + public a: A | null; + + constructor(a: A | null) { + this.a = a; + } + + public setA(a: A) { + this.a = a; + } + + public getA(): A { + return this.a!; + } +} + +function testFieldAccess(): void { + let ac = A.c!; + arktest.assertEQ(ac, c'C', "ac should be 'C'") + + let a_orig = new A(); + let b = new B(a_orig); + + let a = b.a!; + + arktest.assertEQ(a, a_orig, "a should be the object referenced by a_orig") + + let d = b.a!.d!; + + arktest.assertEQ(d, c'D', "d should be 'D'") +} + +function testFieldAccess2(): void { + let a = new A(); + let b = new B(a); + + arktest.assertEQ(b.getA(), a, "getA should return the same object that was given to the constructor") + + let a2 = new A(); + b.setA(a2); + + arktest.assertEQ(b.getA(), a2, "getA should return the same object that was given to setA") +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/objectLiteral.ets b/ets2panda/test/runtime/ets/overload_declaration/objectLiteral.ets new file mode 100644 index 0000000000..2ed459a68b --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/objectLiteral.ets @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { + f: int +} + +class InnerValue { + v: int +} + +class C extends Base { + x: Int = 5 + s: String = "" + iv: InnerValue = {} +} + +function returnC(): C { + return { x: 99, f: 44, s: "qq", iv: { v: 77 } } // return statement +} + +function test1(c: int, f: int, x: int, s: String, ivv: int) { } // should not prevent calling the next fun +function test2(c: C, f: int, x: int, s: String, ivv: int) { + arktest.assertEQ(c.f, f) + arktest.assertEQ(c.x, x) + arktest.assertEQ(c.s, s) + arktest.assertEQ(c.iv.v, ivv) +} + +overload test{ test1, test2 } + +function main(): int { + let c: C = { // variable definition + "x": 7, + s: "sss", + }; + test(c, 0, 7, "sss", 0) + + let c2 = { // as construction + f: 4, + s: "qq" + } as C; + test(c2, 4, 5, "qq", 0) + + c = { f: 5, s: "zzz" } // assignment + test(c, 5, 5, "zzz", 0) + + test({ // function argument + f: 3, + x: 8, + s: "uhuh", + iv: { // object literal field + v: 55 + } + }, 3, 8, "uhuh", 55) + + test(returnC(), 44, 99, "qq", 77) + + let ca: C[] = [{ f: 42, s: "first" }, { f: 128, s: "second" }] // array elements + test(ca[1], 128, 5, "second", 0) + + return 0 +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/overload-primitive-and-object.ets b/ets2panda/test/runtime/ets/overload_declaration/overload-primitive-and-object.ets new file mode 100644 index 0000000000..e27d5f1368 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/overload-primitive-and-object.ets @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2025 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. + */ + +let res: number = 0; +function foo1(i: int, j: int): void { + res = 19; +} +function foo2(i: number, j: Number): void { + res = 21; +} + +overload foo{ foo1, foo2 } + +function boo1(x: Number, y: number) { + res = 34; +} +function boo2(x: number, y: Number) { + res = 47; +} + +overload boo{ boo1, boo2 } + +function main(): void { + let n: Number = new Number(); + foo(1, n); + arktest.assertEQ(res, 21); + boo(6 as Number, 8); + arktest.assertEQ(res, 34); +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-1.ets b/ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-1.ets new file mode 100644 index 0000000000..bdbdab815a --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-1.ets @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2025 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. + */ + +interface I { + s: string; +} + +let res = 0; +function foo2(f1: number, ...args: (Object | null | undefined)[]) { + res = 1; +} + +function foo1(f1: number, i: I, ...args: (Object | null | undefined)[]) { + res = 2; +} + +overload foo{ foo1, foo2 } + +function main(): void { + const i: I = { s: "sss" }; + foo(1, "sss"); + arktest.assertEQ(res, 1); + foo(1, i as I, "sss"); + arktest.assertEQ(res, 2); +} \ No newline at end of file diff --git a/ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-2.ets b/ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-2.ets new file mode 100644 index 0000000000..4fdae60b93 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/overload-resolution-rest-2.ets @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 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. + */ + +class Base { } +class Derived extends Base { } +type BaseOrDerived = Base | Derived; +let res = 0; + +function bar2(p1: Base, p2: Derived, p3: BaseOrDerived) { res = 1; } +function bar1(p1: Derived, p2: Base, p3: BaseOrDerived) { res = 2; } +function bar3(p1: Base, p2: Base, ...p3: BaseOrDerived[]) { res = 3; } + +overload bar{ bar1, bar2, bar3 } + +bar(new Derived, new Base, new Derived); +arktest.assertEQ(res, 2); \ No newline at end of file diff --git a/ets2panda/test/runtime/ets/overload_declaration/overload_1.ets b/ets2panda/test/runtime/ets/overload_declaration/overload_1.ets new file mode 100644 index 0000000000..74a348cbe4 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/overload_1.ets @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2025 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. + */ + +class C { + static $_invoke1() { return C('abc') } + static $_invoke2(p: string) { return p } + static overload $_invoke{ $_invoke1, $_invoke2 } +} + +function main(): int { + if (C() != 'abc') return 1 + return 0 +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/overload_call_1.ets b/ets2panda/test/runtime/ets/overload_declaration/overload_call_1.ets new file mode 100644 index 0000000000..ff5f6e139b --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/overload_call_1.ets @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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. + */ + +class A{} +class B{} +class C{} + +class Test1 { + foo110(a: A): A { + return a; + } + foo112(a: B): B { + return a; + } + + foo113(a: C): C { + console.log(a) + return a; + } + overload foo111{foo110,foo112,foo113} +} + +function main() { + let a: Test1 = new Test1(); + let b = new B(); + a.foo111(b); +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/signature_match_lambda.ets b/ets2panda/test/runtime/ets/overload_declaration/signature_match_lambda.ets new file mode 100644 index 0000000000..c19baccda9 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/signature_match_lambda.ets @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + catch1(onRejected: () => U | PromiseLike): string { + onRejected() + return "first catch is matched" + } + catch2(onRejected: (error: Error) => U | PromiseLike): string { + onRejected(new Error()) + return "second catch is matched" + } + catch3(onRejected: (a: Error, b: Error) => U | PromiseLike): string { + onRejected(new Error(), new Error()) + return "third catch is matched" + } + catch4(onRejected: (a: Error, b: Error, c: Error) => U | PromiseLike): string { + onRejected(new Error(), new Error(), new Error()) + return "fourth catch is matched" + } + overload catch{ catch1, catch2, catch3, catch4 } +} + +function main() { + let a = new A() + arktest.assertEQ(a.catch(() => { }), "first catch is matched") + arktest.assertEQ(a.catch((e: Error | undefined | null) => { }), "second catch is matched") + arktest.assertEQ(a.catch((e: Error) => { }), "second catch is matched") + arktest.assertEQ(a.catch((e: Error, e2: Error) => { }), "third catch is matched") + arktest.assertEQ(a.catch((e: Error, e2: Error, e3: Error) => { }), "fourth catch is matched") +} diff --git a/ets2panda/test/runtime/ets/overload_declaration/visible_signatures.ets b/ets2panda/test/runtime/ets/overload_declaration/visible_signatures.ets new file mode 100644 index 0000000000..d665366294 --- /dev/null +++ b/ets2panda/test/runtime/ets/overload_declaration/visible_signatures.ets @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2025 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. + */ + +class A { + foo11(a: Long): Int { + return 1; + } + private foo12(a: Int): Int { + return 0; + } + + overload foo{ foo11, foo12 } + + foo21(a: Int): Int { + return 1; + } + private foo22(a: Long): Int { + return 0; + } + + overload foo2{ foo21, foo22 } + + foo31(a: Long): Int { + return 1; + } + private foo32(a: Int): Int { + return 0; + } + + overload foo3{ foo31, foo32 } + + foo41(a: Int): Int { + return 1; + } + protected foo42(a: Long): Int { + return 0; + } + + overload foo4{ foo41, foo42 } +} + +function main(): void { + arktest.assertEQ(new A().foo(3), 1) + arktest.assertEQ(new A().foo2(3), 1) + arktest.assertEQ(new A().foo3(3), 1) + arktest.assertEQ(new A().foo4(3), 1) +} diff --git a/ets2panda/util/diagnostic/semantic.yaml b/ets2panda/util/diagnostic/semantic.yaml index fdefeb9872..6b27855c8d 100644 --- a/ets2panda/util/diagnostic/semantic.yaml +++ b/ets2panda/util/diagnostic/semantic.yaml @@ -1516,3 +1516,43 @@ semantic: - name: DYMANIC_INIT_WITH_OBJEXPR id: 382 message: "Dymanic Type {} cannot be initialize with an object expression" + +- name: OVERLOAD_NAME_MUST_BE_IDENTIFIER + id: 383 + message: "The name of overload declaration should be an identifier." + +- name: OVERLOADED_NAME_MUST_FUNCTION + id: 384 + message: "overloaded name must refer to an accessible method." + +- name: DUPLICATE_OVERLOADED_NAME + id: 385 + message: "Duplicate overloaded method." + +- name: OVERLOAD_SAME_ACCESS_MODIFIERS + id: 386 + message: "Overload alias and overloaded method name must have exactly the same modifiers (public, private, protected)." + +- name: OVERLOAD_SAME_ACCESS_MODIFIERS_STATIC_ASYNC + id: 387 + message: "Overload alias and overloaded method name must have exactly the same modifiers (static, async)." + +- name: OVERLOAD_MUST_BOTH_CONSTRUCT + id: 388 + message: "The overload alias and the overloaded method must either both be constructors or both be non-constructors." + +- name: OVERLOADED_NAME_REFER_TO_OVERLOAD_FUNCTION + id: 389 + message: "The overloaded name '{}' can't refer to a function with overload signatures." + +- name: OVERLOADED_NAME_MUST_ALSO_EXPORTED + id: 390 + message: "Overload alias is exported, then overload functions must also be exported." + +- name: OVERLOADED_UNION_CALL + id: 391 + message: "Overload declaration cannot be called by union." + +- name: OVERLOAD_MODIFIERS_ABSTRACT + id: 392 + message: "overload declaration cannot contain abstract methods." diff --git a/ets2panda/util/diagnostic/syntax.yaml b/ets2panda/util/diagnostic/syntax.yaml index 43a5a991a0..707be9029a 100644 --- a/ets2panda/util/diagnostic/syntax.yaml +++ b/ets2panda/util/diagnostic/syntax.yaml @@ -1295,3 +1295,15 @@ syntax: - name: INIT_MODULE_DECLARATION_POSITION id: 322 message: "initModule() must only be called immediately after the import statement, and before any other declarations or statements." + +- name: OVERLOAD_MODIFIERS + id: 323 + message: "Overload Declaration only allow use modifier 'static' | 'async'." + +- name: CLASS_INTERFACE_METHOD_OVERLOADED_NAME_MUST_IDENT + id: 324 + message: "The overloaded method name in class/interface method overload declaration must be identifier." + +- name: FUNCTION_OVERLOADED_NAME_MUST_QUALIFIED_NAME + id: 325 + message: "The overloaded method name in function overload declaration must be qualified name." \ No newline at end of file diff --git a/ets2panda/util/diagnosticEngine.cpp b/ets2panda/util/diagnosticEngine.cpp index 9e294a8cf8..6f92ba5cd0 100644 --- a/ets2panda/util/diagnosticEngine.cpp +++ b/ets2panda/util/diagnosticEngine.cpp @@ -37,6 +37,29 @@ const DiagnosticStorage &DiagnosticEngine::GetDiagnosticStorage(DiagnosticType t return diagnostics_[type]; } +[[nodiscard]] DiagnosticCheckpoint DiagnosticEngine::Save() const +{ + DiagnosticCheckpoint cp; + for (size_t i = 0; i < diagnostics_.size(); i++) { + cp[i] = diagnostics_[i].size(); + } + return cp; +} + +void DiagnosticEngine::Rollback(const DiagnosticCheckpoint &checkpoint) +{ + for (size_t i = 0; i < diagnostics_.size(); i++) { + diagnostics_[i].resize(checkpoint[i]); + } +} + +void DiagnosticEngine::UndoRange(const DiagnosticCheckpoint &from, const DiagnosticCheckpoint &to) +{ + for (size_t i = 0; i < diagnostics_.size(); i++) { + diagnostics_[i].erase(diagnostics_[i].begin() + from[i], diagnostics_[i].begin() + to[i]); + } +} + [[noreturn]] void DiagnosticEngine::Throw(ThrowableDiagnostic diag) const { throw diag; diff --git a/ets2panda/util/diagnosticEngine.h b/ets2panda/util/diagnosticEngine.h index 015dc4d6ad..d50fd12b24 100644 --- a/ets2panda/util/diagnosticEngine.h +++ b/ets2panda/util/diagnosticEngine.h @@ -48,6 +48,8 @@ public: using DiagnosticStorage = std::vector>; +using DiagnosticCheckpoint = std::array; + class DiagnosticEngine { public: explicit DiagnosticEngine() : printer_(std::make_unique()) @@ -65,6 +67,12 @@ public: // NOTE(schernykh): should be removed const DiagnosticBase &GetAnyError() const; + DiagnosticCheckpoint Save() const; + + void Rollback(const DiagnosticCheckpoint &checkpoint); + + void UndoRange(const DiagnosticCheckpoint &from, const DiagnosticCheckpoint &to); + [[nodiscard]] bool IsAnyError() const noexcept; template diff --git a/ets2panda/varbinder/ETSBinder.cpp b/ets2panda/varbinder/ETSBinder.cpp index 0cfc10ccce..10db15de91 100644 --- a/ets2panda/varbinder/ETSBinder.cpp +++ b/ets2panda/varbinder/ETSBinder.cpp @@ -432,6 +432,11 @@ void ETSBinder::ResolveMethodDefinition(ir::MethodDefinition *methodDef) thisParam->Declaration()->BindNode(thisParam_); } +void ETSBinder::BuildOverloadDeclaration(ir::OverloadDeclaration *overloadDef) +{ + overloadDef->ResolveReferences([this](auto *childNode) { ResolveReference(childNode); }); +} + void ETSBinder::BuildMemberExpression(ir::MemberExpression *memberExpr) { ResolveReference(memberExpr->Object()); @@ -1156,6 +1161,9 @@ void ETSBinder::HandleCustomNodes(ir::AstNode *childNode) case ir::AstNodeType::METHOD_DEFINITION: { return BuildMethodDefinition(childNode->AsMethodDefinition()); } + case ir::AstNodeType::OVERLOAD_DECLARATION: { + return BuildOverloadDeclaration(childNode->AsOverloadDeclaration()); + } case ir::AstNodeType::ETS_NEW_CLASS_INSTANCE_EXPRESSION: { return BuildETSNewClassInstanceExpression(childNode->AsETSNewClassInstanceExpression()); } @@ -1242,10 +1250,11 @@ void ETSBinder::BuildFunctionName(const ir::ScriptFunction *func) const << compiler::Signatures::METHOD_SEPARATOR; const auto *signature = func->Signature(); + const auto funcName = util::Helpers::FunctionName(Allocator(), func); if (func->IsStaticBlock()) { ss << compiler::Signatures::CCTOR; - } else if (func->IsConstructor()) { + } else if (func->IsConstructor() && funcName.Is(compiler::Signatures::CONSTRUCTOR_NAME)) { ss << compiler::Signatures::CTOR; } else { if (func->IsGetter()) { @@ -1253,7 +1262,7 @@ void ETSBinder::BuildFunctionName(const ir::ScriptFunction *func) const } else if (func->IsSetter()) { ss << compiler::Signatures::SETTER_BEGIN; } - ss << util::Helpers::FunctionName(Allocator(), func); + ss << funcName; } signature->ToAssemblerType(ss); diff --git a/ets2panda/varbinder/ETSBinder.h b/ets2panda/varbinder/ETSBinder.h index d5b6e9888d..001a02cb10 100644 --- a/ets2panda/varbinder/ETSBinder.h +++ b/ets2panda/varbinder/ETSBinder.h @@ -137,6 +137,7 @@ public: void BuildInterfaceDeclaration(ir::TSInterfaceDeclaration *decl); void BuildMemberExpression(ir::MemberExpression *memberExpr); void BuildMethodDefinition(ir::MethodDefinition *methodDef); + void BuildOverloadDeclaration(ir::OverloadDeclaration *overloadDef); void BuildAnnotationDeclaration(ir::AnnotationDeclaration *annoDecl); void BuildAnnotationUsage(ir::AnnotationUsage *annoUsage); void BuildImportDeclaration(ir::ETSImportDeclaration *decl); diff --git a/ets2panda/varbinder/variableFlags.h b/ets2panda/varbinder/variableFlags.h index 5ec081c2e6..12d8b6ff8c 100644 --- a/ets2panda/varbinder/variableFlags.h +++ b/ets2panda/varbinder/variableFlags.h @@ -166,6 +166,7 @@ enum class VariableFlags : uint64_t { NAMESPACE = 1ULL << 35ULL, INIT_IN_STATIC_BLOCK = 1ULL << 36ULL, DYNAMIC = 1ULL << 37ULL, + OVERLOAD = 1ULL << 38ULL, HOIST_VAR = HOIST | VAR, CLASS_OR_INTERFACE = CLASS | INTERFACE, -- Gitee From 496f2a4d5db3c31458117f3fc138424e24a7ff24 Mon Sep 17 00:00:00 2001 From: fcc Date: Tue, 24 Jun 2025 16:24:45 +0800 Subject: [PATCH 2/3] fix crash related to rest parameter Avoid crash related to rest parameter. Issue: https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICFY21 Signed-off-by: fcc --- ets2panda/checker/ets/function.cpp | 7 +++--- .../ast/compiler/ets/restvar_type_infer.ets | 22 +++++++++++++++++++ .../annotationUsage_bad_param07.ets | 1 + 3 files changed, 26 insertions(+), 4 deletions(-) create mode 100644 ets2panda/test/ast/compiler/ets/restvar_type_infer.ets diff --git a/ets2panda/checker/ets/function.cpp b/ets2panda/checker/ets/function.cpp index 7740649e4c..d2423c24ca 100644 --- a/ets2panda/checker/ets/function.cpp +++ b/ets2panda/checker/ets/function.cpp @@ -1559,10 +1559,6 @@ static varbinder::LocalVariable *SetupSignatureParameter(ir::ETSParameterExpress // Should be moved to original ComposeSignatureInfo after AST fix static bool AppendSignatureInfoParam(ETSChecker *checker, SignatureInfo *sigInfo, ir::ETSParameterExpression *param) { - if (param->IsRestParameter()) { - return true; - } - auto variable = SetupSignatureParameter(param, [checker, param]() { if (param->TypeAnnotation() != nullptr) { auto type = param->TypeAnnotation()->GetType(checker); @@ -1581,6 +1577,9 @@ static bool AppendSignatureInfoParam(ETSChecker *checker, SignatureInfo *sigInfo if (variable == nullptr) { // #23134 return false; } + if (param->IsRestParameter()) { + return true; + } sigInfo->params.push_back(variable); if (!param->IsOptional()) { diff --git a/ets2panda/test/ast/compiler/ets/restvar_type_infer.ets b/ets2panda/test/ast/compiler/ets/restvar_type_infer.ets new file mode 100644 index 0000000000..578567a54a --- /dev/null +++ b/ets2panda/test/ast/compiler/ets/restvar_type_infer.ets @@ -0,0 +1,22 @@ +/* +* Copyright (c) 2025 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 low 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. +*/ + +function main() { + let r1 = ((...args) =>{ return args.length; })(1,2,3); + let r2 = ((a:number, ...args)=> { return args.length; })(1,2,3,4,5) +} + +/* @@? 17:16 Error TypeError: The type of parameter 'args' cannot be inferred */ +/* @@? 18:26 Error TypeError: The type of parameter 'args' cannot be inferred */ diff --git a/ets2panda/test/ast/parser/ets/annotations_tests/annotationUsage_bad_param07.ets b/ets2panda/test/ast/parser/ets/annotations_tests/annotationUsage_bad_param07.ets index c1e3d6541e..93b781dc7b 100644 --- a/ets2panda/test/ast/parser/ets/annotations_tests/annotationUsage_bad_param07.ets +++ b/ets2panda/test/ast/parser/ets/annotations_tests/annotationUsage_bad_param07.ets @@ -23,3 +23,4 @@ function foo(@MyAnno ...a/* @@ label */){} /* @@@ label Error SyntaxError: Parameter declaration should have an explicit type annotation. */ /* @@? 22:15 Error TypeError: The required field 'testProperty1' must be specified. Fields without default values cannot be omitted. */ +/* @@? 22:22 Error TypeError: The type of parameter 'a' cannot be inferred */ -- Gitee From 8b59afa97e21124810f4058009a1fbd63d722f5e Mon Sep 17 00:00:00 2001 From: xingshunxiang Date: Tue, 24 Jun 2025 15:36:34 +0800 Subject: [PATCH 3/3] Fix Line Table For Trailing Lambda Issue: https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICHFNF?from=project-issue Description: cannot generate line table for trailing lambda Reason: 1. the source range of init method of ETSGLOBAL was incorrectly set by 0,0; 2. the source range of a call expression with trailing lambda should be set as {callexpr start} to {trailing block end}, but now it was set as {callexpr start} to {callexpr end} 3. so the 1 and 2 will make the source range of the trailing block become 0,0 after lowering Tests: ninja tests passed tests/tests-u-runner/runner.sh --ets-cts --show-progress --build-dir x64.release --processes=all passed tests/tests-u-runner/runner.sh --ets-func-tests --show-progress --build-dir x64.release --processes=all passed tests/tests-u-runner/runner.sh --astchecker --show-progress --build-dir x64.release --processes=all passed tests/tests-u-runner/runner.sh --ets-runtime --show-progress --build-dir x64.release --processes=all passed tests/tests-u-runner/runner.sh --parser --no-js --show-progress --build-dir x64.release --processes=all passed Signed-off-by: xingshunxiang --- .../ets/topLevelStmts/globalClassHandler.cpp | 19 ++++++- ets2panda/parser/expressionParser.cpp | 3 + .../test/compiler/ets/116100-expected.txt | 56 +++++++++---------- ...ditionalExpressionCallVoidNeg-expected.txt | 12 ++-- .../compiler/ets/FunctionType2-expected.txt | 12 ++-- .../compiler/ets/FunctionType4-expected.txt | 44 +++++++-------- ...ctMethodDeclaredInParentClass-expected.txt | 24 ++++---- ...actNewClassInstanceExpression-expected.txt | 56 +++++++++---------- .../ets/ambient_declaration-expected.txt | 12 ++-- ..._without_chaining_non_nullish-expected.txt | 56 +++++++++---------- .../ets/array_with_null_type-expected.txt | 12 ++-- .../array_with_undefined_type-expected.txt | 12 ++-- .../ets/arrowFunctionCapture-expected.txt | 24 ++++---- .../ets/boxingConversion10-expected.txt | 56 +++++++++---------- .../ets/boxingConversion2-expected.txt | 12 ++-- .../ets/boxingConversion3-expected.txt | 12 ++-- .../ets/boxingConversion5-expected.txt | 56 +++++++++---------- .../ets/boxingConversion6-expected.txt | 56 +++++++++---------- .../ets/boxingConversion7-expected.txt | 56 +++++++++---------- .../ets/boxingConversion8-expected.txt | 56 +++++++++---------- .../ets/boxingConversion9-expected.txt | 56 +++++++++---------- .../boxingUnboxingExpressions-expected.txt | 24 ++++---- .../ets/catch-soft-keyword-expected.txt | 24 ++++---- .../compiler/ets/catchParamScope-expected.txt | 12 ++-- .../ets/class_def_varargs_1-expected.txt | 24 ++++---- .../ets/class_def_varargs_2-expected.txt | 12 ++-- .../ets/conversion-w-ASExpr-expected.txt | 12 ++-- .../ets/conversion_w_functions-expected.txt | 12 ++-- .../ets/delete-non-keyword-expected.txt | 24 ++++---- .../ensureNotNullArgNotNullable-expected.txt | 12 ++-- ...ensureNotNullLocalNotNullable-expected.txt | 12 ++-- ...nsureNotNullReturnNotNullable-expected.txt | 12 ++-- ...as_class_member_getValue_call-expected.txt | 24 ++++---- .../compiler/ets/export_type-expected.txt | 24 ++++---- ...ed_conditional_expression_not-expected.txt | 24 ++++---- ...al_expression_not_return_type-expected.txt | 24 ++++---- .../test/compiler/ets/forUpdate-expected.txt | 24 ++++---- .../ets/forUpdateCharType-expected.txt | 12 ++-- .../ets/from-soft-keyword-0-expected.txt | 12 ++-- .../ets/from-soft-keyword-1-expected.txt | 12 ++-- .../ets/from-soft-keyword-2-expected.txt | 12 ++-- .../ets/func-ref-private-expected.txt | 24 ++++---- .../ets/functionPointerArray-expected.txt | 12 ++-- .../ets/functionTypeToObject-expected.txt | 12 ++-- .../ets/function_subtyping_1-expected.txt | 12 ++-- ...with_ambiguous_rest_parameter-expected.txt | 12 ++-- .../ets/generic_arrayaslist-expected.txt | 24 ++++---- .../generic_class_getter_setter-expected.txt | 12 ++-- .../ets/generic_deadlock-expected.txt | 12 ++-- ..._func_rest_param_spread_infer-expected.txt | 12 ++-- .../ets/generic_function_call_1-expected.txt | 12 ++-- .../ets/generic_function_call_3-expected.txt | 12 ++-- .../ets/generic_function_call_4-expected.txt | 12 ++-- .../ets/generic_function_call_5-expected.txt | 24 ++++---- .../ets/generic_function_call_7-expected.txt | 12 ++-- .../ets/generic_override_1-expected.txt | 24 ++++---- .../ets/generic_override_2-expected.txt | 24 ++++---- .../ets/generic_override_3-expected.txt | 24 ++++---- .../ets/generic_typealias_1-expected.txt | 12 ++-- .../ets/generic_typealias_6-expected.txt | 12 ++-- .../ets/generic_typealias_7_neg-expected.txt | 12 ++-- .../ets/generic_typealias_8-expected.txt | 12 ++-- .../ets/generic_typealias_9-expected.txt | 12 ++-- .../ets/generic_variance_1-expected.txt | 12 ++-- ...nerics_class_recursive_type_1-expected.txt | 24 ++++---- .../generics_implicit_lambda1-expected.txt | 16 +++--- .../ets/generics_instantiation_1-expected.txt | 24 ++++---- .../ets/generics_instantiation_2-expected.txt | 24 ++++---- .../ets/generics_instantiation_3-expected.txt | 24 ++++---- .../ets/generics_instantiation_4-expected.txt | 24 ++++---- .../generics_interface_bounds_1-expected.txt | 24 ++++---- .../generics_interface_bounds_2-expected.txt | 24 ++++---- ...nerics_primitive_type_param_1-expected.txt | 24 ++++---- .../ets/identifierReference14-expected.txt | 24 ++++---- .../ets/identifierReference4-expected.txt | 56 +++++++++---------- .../ets/implicit-conversion-expected.txt | 12 ++-- .../package_module_1-expected.txt | 40 ++++++------- .../package_module_2-expected.txt | 44 +++++++-------- .../separate_module_1-expected.txt | 56 +++++++++---------- .../package_module_1-expected.txt | 16 +++--- .../package_module_2-expected.txt | 16 +++--- .../separate_module_1-expected.txt | 56 +++++++++---------- .../asyncfun_lambda_lib-expected.txt | 24 ++++---- .../asyncfunc_lambda_main-expected.txt | 12 ++-- .../ets/import_tests/enum_export-expected.txt | 24 ++++---- .../ets/import_tests/enum_import-expected.txt | 12 ++-- ...rt_class_with_getters_setters-expected.txt | 24 ++++---- .../generic_typealias_func_type-expected.txt | 12 ++-- ...neric_typealias_func_type_lib-expected.txt | 24 ++++---- ...rt_class_with_getters_setters-expected.txt | 12 ++-- ...imported_function_return_type-expected.txt | 12 ++-- ...rted_function_return_type_lib-expected.txt | 24 ++++---- .../re-export_with_alias/export-expected.txt | 56 +++++++++---------- .../import_aliased_re-export-expected.txt | 12 ++-- .../re-export_with_alias-expected.txt | 24 ++++---- .../import_interface-expected.txt | 24 ++++---- .../import_selective_exported-expected.txt | 12 ++-- .../selective_export-expected.txt | 56 +++++++++---------- .../selective_export_function-expected.txt | 24 ++++---- .../selective_export_interface-expected.txt | 24 ++++---- .../selective_export_with_alias-expected.txt | 56 +++++++++---------- ...selective_import_with_alias_1-expected.txt | 24 ++++---- ...selective_import_with_alias_2-expected.txt | 24 ++++---- .../compiler/ets/import_type-expected.txt | 48 ++++++++-------- .../ets/inferTypeOfArray-expected.txt | 56 +++++++++---------- .../ets/instanceof_object_long-expected.txt | 24 ++++---- ...erface_noreturn_type_function-expected.txt | 12 ++-- .../ets/invalidCallInstruction-expected.txt | 12 ++-- .../ets/invalidInheritance3-expected.txt | 24 ++++---- .../compiler/ets/lambdaFunction1-expected.txt | 44 +++++++-------- ...ambdaFunctionArrayDeclaration-expected.txt | 12 ++-- .../ets/lambda_capturing-expected.txt | 24 ++++---- ...bda_cast_infer_type_narrowing-expected.txt | 24 ++++---- .../lambda_cast_infer_type_void-expected.txt | 12 ++-- ...mbda_cast_infer_type_widening-expected.txt | 24 ++++---- .../lambda_cast_type_has_pramas-expected.txt | 12 ++-- .../lambda_infer_type-expected.txt | 12 ++-- ...a_infer_type_arrow_expression-expected.txt | 24 ++++---- ...type_arrow_expression_literal-expected.txt | 24 ++++---- .../lambda_infer_type_has_return-expected.txt | 24 ++++---- .../lambda_infer_type_param2-expected.txt | 12 ++-- ...ambda_infer_type_return_array-expected.txt | 12 ++-- ...mbda_infer_type_return_lambda-expected.txt | 12 ++-- ...bda_infer_type_return_lambda1-expected.txt | 12 ++-- ...type_return_lambda_expression-expected.txt | 56 +++++++++---------- ...bda_infer_type_return_literal-expected.txt | 12 ++-- ...ambda_infer_type_return_union-expected.txt | 12 ++-- .../lambda_infer_type_scope-expected.txt | 44 +++++++-------- .../ets/lambda_unresolved_ref_1-expected.txt | 12 ++-- .../ets/launch_expression-expected.txt | 44 +++++++-------- .../ets/loopWithinLambda-expected.txt | 12 ++-- .../ets/lowering-interaction-expected.txt | 24 ++++---- .../ets/manyLocalsParamRegUsage-expected.txt | 24 ++++---- .../ets/memberExprInLambda-expected.txt | 24 ++++---- ...erExpressionFromStaticContext-expected.txt | 24 ++++---- ...and-interface-in-signatures_5-expected.txt | 12 ++-- .../methodOverrideAsyncMethod-expected.txt | 24 ++++---- ...odOverrideCovariantReturnType-expected.txt | 24 ++++---- ...hodOverrideDifferentSignature-expected.txt | 24 ++++---- ...methodOverrideWithoutModifier-expected.txt | 24 ++++---- .../ets/multipleMethodOverride-expected.txt | 24 ++++---- .../n_nullableTypeInArgNotRef-expected.txt | 12 ++-- .../n_nullableTypeInReturnNotRef-expected.txt | 12 ++-- .../ets/n_nullableTypeNotRef-expected.txt | 12 ++-- .../compiler/ets/native_toplevel-expected.txt | 24 ++++---- .../non-const-lambda-with-scopes-expected.txt | 12 ++-- .../null_coalescing_generic_1-expected.txt | 24 ++++---- .../compiler/ets/nullableTuple-expected.txt | 12 ++-- ...ullable_type_in_arithmeticdiv-expected.txt | 12 ++-- ...llable_type_in_arithmeticplus-expected.txt | 12 ++-- .../ets/objectLiteralInterface-expected.txt | 56 +++++++++---------- .../ets/objectLiteralReadonlyKey-expected.txt | 56 +++++++++---------- .../ets/overload_with_generics-expected.txt | 12 ++-- .../test/compiler/ets/override-expected.txt | 12 ++-- .../test/compiler/ets/override10-expected.txt | 24 ++++---- .../test/compiler/ets/override12-expected.txt | 24 ++++---- .../test/compiler/ets/override13-expected.txt | 24 ++++---- .../test/compiler/ets/override16-expected.txt | 24 ++++---- .../test/compiler/ets/override17-expected.txt | 24 ++++---- .../test/compiler/ets/override19-expected.txt | 12 ++-- .../test/compiler/ets/override2-expected.txt | 24 ++++---- .../test/compiler/ets/override4-expected.txt | 24 ++++---- .../test/compiler/ets/override5-expected.txt | 24 ++++---- .../test/compiler/ets/override6-expected.txt | 24 ++++---- .../test/compiler/ets/override8-expected.txt | 24 ++++---- .../test/compiler/ets/override9-expected.txt | 24 ++++---- .../ets/parenthesizedType-expected.txt | 12 ++-- .../compiler/ets/requiredType_1-expected.txt | 12 ++-- .../compiler/ets/requiredType_11-expected.txt | 12 ++-- .../compiler/ets/requiredType_4-expected.txt | 12 ++-- .../compiler/ets/requiredType_5-expected.txt | 12 ++-- .../compiler/ets/requiredType_9-expected.txt | 12 ++-- .../ets/rethrowingCheck1-expected.txt | 24 ++++---- .../ets/rethrowingCheck4-expected.txt | 24 ++++---- .../rethrowingConstructorCheck3-expected.txt | 12 ++-- .../ets/rethrowingFunctionCheck3-expected.txt | 12 ++-- .../ets/rethrowingMethodCheck3-expected.txt | 12 ++-- .../ets/returnTypeGenericArray-expected.txt | 24 ++++---- .../ets/switchStatementBoxing-expected.txt | 24 ++++---- ...tchStatementCorrectConversion-expected.txt | 24 ++++---- .../this_type_valid_return_type-expected.txt | 24 ++++---- .../ets/throwInCatchClause3-expected.txt | 24 ++++---- .../ets/throwInFinallyBlock1-expected.txt | 12 ++-- .../throwInRethrowingFunction2-expected.txt | 24 ++++---- .../ets/throwInThrowingFunction-expected.txt | 24 ++++---- .../ets/throwInTryStatement-expected.txt | 12 ++-- .../throwingFunctionAsParameter1-expected.txt | 24 ++++---- .../ets/throwingFunctionCheck2-expected.txt | 12 ++-- .../ets/throwingFunctionCheck3-expected.txt | 12 ++-- .../ets/throwingFunctionCheck6-expected.txt | 12 ++-- .../ets/throwingFunctionType1-expected.txt | 12 ++-- ...tryCatchErrorMissingParamType-expected.txt | 12 ++-- .../ets/tryCatchMissingParamType-expected.txt | 12 ++-- .../ets/tryDefaultCatches-expected.txt | 12 ++-- .../compiler/ets/tuple_types_1-expected.txt | 12 ++-- .../compiler/ets/tuple_types_12-expected.txt | 12 ++-- .../compiler/ets/tuple_types_13-expected.txt | 24 ++++---- .../compiler/ets/tuple_types_14-expected.txt | 12 ++-- .../compiler/ets/tuple_types_15-expected.txt | 12 ++-- .../compiler/ets/tuple_types_16-expected.txt | 12 ++-- .../compiler/ets/tuple_types_17-expected.txt | 12 ++-- .../compiler/ets/tuple_types_18-expected.txt | 12 ++-- .../compiler/ets/tuple_types_19-expected.txt | 24 ++++---- .../compiler/ets/tuple_types_7-expected.txt | 12 ++-- .../test/compiler/ets/typeAlias-expected.txt | 56 +++++++++---------- ...arReferenceFromStaticContext2-expected.txt | 24 ++++---- .../compiler/ets/union_types_1-expected.txt | 12 ++-- .../compiler/ets/union_types_3-expected.txt | 12 ++-- .../compiler/ets/union_types_5-expected.txt | 12 ++-- .../ets/union_types_merging-expected.txt | 12 ++-- .../parser/ets/AccessBinaryTrees-expected.txt | 12 ++-- .../parser/ets/AccessFannkuch-expected.txt | 12 ++-- .../test/parser/ets/AccessNBody-expected.txt | 12 ++-- .../test/parser/ets/AccessNSieve-expected.txt | 12 ++-- .../ets/Bitops3BitBitsInByte-expected.txt | 12 ++-- .../parser/ets/BitopsBitsInByte-expected.txt | 12 ++-- .../parser/ets/BitopsBitwiseAnd-expected.txt | 12 ++-- .../parser/ets/BitopsNSieveBits-expected.txt | 12 ++-- .../parser/ets/Boolean_bitwise-expected.txt | 12 ++-- .../ets/ControlFlowRecursive-expected.txt | 12 ++-- .../parser/ets/Dollar_dollar_1-expected.txt | 56 +++++++++---------- .../parser/ets/Dollar_dollar_2-expected.txt | 24 ++++---- .../parser/ets/Dollar_dollar_3-expected.txt | 56 +++++++++---------- .../parser/ets/Dollar_dollar_4-expected.txt | 56 +++++++++---------- .../parser/ets/FunctionInSwitch-expected.txt | 20 +++---- .../test/parser/ets/FunctionType-expected.txt | 24 ++++---- .../FunctionalTypeAsTypeArgument-expected.txt | 24 ++++---- .../ets/InferTypeParamFromParam1-expected.txt | 12 ++-- .../ets/InferTypeParamFromParam3-expected.txt | 12 ++-- .../test/parser/ets/MathCordic-expected.txt | 12 ++-- .../parser/ets/MathPartialSums-expected.txt | 12 ++-- .../parser/ets/MathSpectralNorm-expected.txt | 12 ++-- .../test/parser/ets/Morph3d-expected.txt | 12 ++-- ...ametersWithGenericReturnTypes-expected.txt | 24 ++++---- .../StaticFieldAndMethodSameName-expected.txt | 12 ++-- ...dAndMethodSameNameInheritance-expected.txt | 12 ++-- .../test/parser/ets/StringBase64-expected.txt | 12 ++-- .../parser/ets/access_modifier_2-expected.txt | 24 ++++---- .../parser/ets/access_modifier_3-expected.txt | 24 ++++---- .../ets/ambient_call_signature-expected.txt | 12 ++-- .../parser/ets/ambient_indexer_1-expected.txt | 12 ++-- .../parser/ets/ambient_indexer_6-expected.txt | 12 ++-- .../ets/ambient_object_iterable-expected.txt | 12 ++-- ets2panda/test/parser/ets/array-expected.txt | 56 +++++++++---------- .../ets/arrayHoldingNullValue-expected.txt | 44 +++++++-------- .../ets/arrayLiteralReassign-expected.txt | 12 ++-- .../array_creation_expression-expected.txt | 12 ++-- ...sion_implicit_cast_assignment-expected.txt | 24 ++++---- ...pression_implicit_cast_return-expected.txt | 24 ++++---- .../test/parser/ets/array_new-expected.txt | 24 ++++---- .../ets/array_type_from_literal-expected.txt | 24 ++++---- ...s_expression_unary_expression-expected.txt | 12 ++-- ets2panda/test/parser/ets/assert-expected.txt | 24 ++++---- ets2panda/test/parser/ets/assign-expected.txt | 44 +++++++-------- .../test/parser/ets/assign-func-expected.txt | 24 ++++---- ...ableFromMethodToNullableParam-expected.txt | 12 ++-- .../assignNullableToNonNullable-expected.txt | 12 ++-- ...ignNullableToNonNullableArray-expected.txt | 12 ++-- ...ullableToNonNullableTypeAlias-expected.txt | 12 ++-- .../test/parser/ets/assignments-expected.txt | 24 ++++---- .../ets/async_func_return_type-expected.txt | 24 ++++---- .../parser/ets/async_function-expected.txt | 56 +++++++++---------- .../parser/ets/async_overload-expected.txt | 12 ++-- .../parser/ets/async_with_lambda-expected.txt | 24 ++++---- .../ets/await_complex_promise-expected.txt | 24 ++++---- .../parser/ets/await_keyword-expected.txt | 56 +++++++++---------- .../test/parser/ets/binary_op-expected.txt | 56 +++++++++---------- .../parser/ets/binary_operations-expected.txt | 24 ++++---- ets2panda/test/parser/ets/blocks-expected.txt | 48 ++++++++-------- .../parser/ets/blocks_scopes-expected.txt | 48 ++++++++-------- .../test/parser/ets/boolean-expected.txt | 56 +++++++++---------- .../test/parser/ets/boolean_cond-expected.txt | 12 ++-- .../parser/ets/boolean_default-expected.txt | 12 ++-- ets2panda/test/parser/ets/break-expected.txt | 44 +++++++-------- ...callFunctionWithNullableParam-expected.txt | 12 ++-- ...erfaceMethodWithNullableParam-expected.txt | 12 ++-- .../callMethodWithNullableParam-expected.txt | 12 ++-- .../calling_superclass_methods-expected.txt | 24 ++++---- .../parser/ets/cast_const_union-expected.txt | 44 +++++++-------- .../parser/ets/cast_expressions-expected.txt | 24 ++++---- .../parser/ets/cast_expressions3-expected.txt | 24 ++++---- .../parser/ets/cast_expressions4-expected.txt | 24 ++++---- .../parser/ets/cast_expressions5-expected.txt | 56 +++++++++---------- .../test/parser/ets/class_init-expected.txt | 24 ++++---- .../parser/ets/class_instance-expected.txt | 56 +++++++++---------- .../ets/class_instance_creation-expected.txt | 24 ++++---- .../class_instance_import_alias-expected.txt | 12 ++-- .../class_instance_initializer-expected.txt | 24 ++++---- ...terface_enum_only_top_level_4-expected.txt | 12 ++-- .../ets/class_static_initializer-expected.txt | 24 ++++---- .../test/parser/ets/classes-expected.txt | 24 ++++---- .../parser/ets/comment_block-expected.txt | 24 ++++---- .../test/parser/ets/comment_line-expected.txt | 24 ++++---- .../conditionalExpressionType-expected.txt | 12 ++-- ets2panda/test/parser/ets/const-expected.txt | 24 ++++---- .../constructorThrowsRethrows-expected.txt | 24 ++++---- .../ets/constructor_super_call1-expected.txt | 24 ++++---- .../ets/constructor_super_call3-expected.txt | 24 ++++---- .../parser/ets/constructor_test-expected.txt | 24 ++++---- .../constructor_with_return_2-expected.txt | 24 ++++---- .../test/parser/ets/continue-expected.txt | 44 +++++++-------- .../test/parser/ets/conversions-expected.txt | 12 ++-- .../test/parser/ets/decl_infer-expected.txt | 56 +++++++++---------- ...eclare_ambient_const_variable-expected.txt | 12 ++-- .../ets/default_parameter10-expected.txt | 12 ++-- .../ets/default_parameter5-expected.txt | 12 ++-- .../ets/default_parameter7-expected.txt | 24 ++++---- .../ets/default_parameter9-expected.txt | 24 ++++---- ..._implicitly_typed_return_void-expected.txt | 12 ++-- .../dynamic_optional_decl-expected.txt | 12 ++-- .../test/parser/ets/empty_class-expected.txt | 24 ++++---- .../parser/ets/empty_statement-expected.txt | 24 ++++---- .../test/parser/ets/exports-expected.txt | 56 +++++++++---------- ...rnal_cyclic_constructor_check-expected.txt | 12 ++-- .../test/parser/ets/field_decl-expected.txt | 24 ++++---- .../parser/ets/final_empty_class-expected.txt | 24 ++++---- .../ets/float_pont_format_1-expected.txt | 12 ++-- .../ets/float_pont_format_2-expected.txt | 12 ++-- .../ets/float_pont_format_3-expected.txt | 12 ++-- .../ets/float_pont_format_4-expected.txt | 12 ++-- .../ets/float_pont_format_5-expected.txt | 12 ++-- .../ets/float_pont_format_6-expected.txt | 12 ++-- .../ets/float_pont_format_7-expected.txt | 12 ++-- .../ets/float_pont_format_8-expected.txt | 12 ++-- .../parser/ets/float_separator_1-expected.txt | 12 ++-- .../folder_import_index/index-expected.txt | 24 ++++---- ets2panda/test/parser/ets/for_of-expected.txt | 44 +++++++-------- .../parser/ets/for_with_break-expected.txt | 12 ++-- .../parser/ets/forofUnboxing-expected.txt | 12 ++-- .../funcParamWithOptionalParam-expected.txt | 24 ++++---- .../test/parser/ets/function-expected.txt | 56 +++++++++---------- .../ets/functionThrowsRethrows-expected.txt | 24 ++++---- .../ets/functionTypeThrows-expected.txt | 24 ++++---- ...unction_implicit_return_type5-expected.txt | 24 ++++---- ...unction_implicit_return_type6-expected.txt | 12 ++-- ...unction_implicit_return_type8-expected.txt | 12 ++-- ...unction_implicit_return_type9-expected.txt | 12 ++-- .../ets/genericDefaultParam_1-expected.txt | 40 ++++++------- .../ets/genericDefaultParam_3-expected.txt | 48 ++++++++-------- .../parser/ets/generic_function-expected.txt | 24 ++++---- .../parser/ets/generic_resolve-expected.txt | 24 ++++---- .../test/parser/ets/generics_2-expected.txt | 24 ++++---- .../test/parser/ets/generics_3-expected.txt | 12 ++-- .../test/parser/ets/generics_4-expected.txt | 12 ++-- .../test/parser/ets/generics_5-expected.txt | 12 ++-- .../test/parser/ets/generics_6-expected.txt | 12 ++-- .../test/parser/ets/generics_7-expected.txt | 12 ++-- .../ets/generics_recursive-expected.txt | 24 ++++---- ...erics_type_param_constraint_1-expected.txt | 12 ++-- ...rics_type_param_constraint_10-expected.txt | 12 ++-- ...rics_type_param_constraint_11-expected.txt | 24 ++++---- ...rics_type_param_constraint_12-expected.txt | 24 ++++---- ...erics_type_param_constraint_2-expected.txt | 24 ++++---- ...erics_type_param_constraint_3-expected.txt | 24 ++++---- ...erics_type_param_constraint_4-expected.txt | 24 ++++---- ...erics_type_param_constraint_5-expected.txt | 24 ++++---- ...erics_type_param_constraint_6-expected.txt | 12 ++-- ...erics_type_param_constraint_7-expected.txt | 12 ++-- ...erics_type_param_constraint_9-expected.txt | 12 ++-- .../parser/ets/getterOverride-expected.txt | 24 ++++---- ...etter_setter_access_modifiers-expected.txt | 24 ++++---- .../globalVarInLambdaInStatic-expected.txt | 24 ++++---- .../ets/global_const_vars3-expected.txt | 24 ++++---- .../test/parser/ets/identifier-expected.txt | 56 +++++++++---------- ets2panda/test/parser/ets/if-expected.txt | 24 ++++---- ets2panda/test/parser/ets/ifs-expected.txt | 24 ++++---- .../test/parser/ets/import_conts-expected.txt | 12 ++-- .../parser/ets/import_folder-expected.txt | 48 ++++++++-------- .../check_exported_2-expected.txt | 24 ++++---- .../check_exported_3-expected.txt | 24 ++++---- .../check_exported_default_class-expected.txt | 12 ++-- .../import_tests/default_import-expected.txt | 12 ++-- .../import_tests/diamond/test1-expected.txt | 12 ++-- .../import_tests/diamond/test2-expected.txt | 56 +++++++++---------- .../import_tests/diamond/test3-expected.txt | 56 +++++++++---------- .../import_tests/diamond/test4-expected.txt | 56 +++++++++---------- .../duplicated/classdef-expected.txt | 24 ++++---- .../duplicated/extdef-expected.txt | 24 ++++---- .../duplicated/extusedef-expected.txt | 12 ++-- .../export_type_alias-expected.txt | 24 ++++---- .../separate_module-expected.txt | 56 +++++++++---------- .../import_alias/export-expected.txt | 56 +++++++++---------- .../import_alias/import_alias_1-expected.txt | 12 ++-- ...ort_alias_and_without_alias_1-expected.txt | 12 ++-- ...ort_alias_and_without_alias_2-expected.txt | 12 ++-- ...ort_alias_and_without_alias_3-expected.txt | 12 ++-- .../ets/import_tests/import_all-expected.txt | 56 +++++++++---------- .../import_tests/import_all_3-expected.txt | 12 ++-- .../import_all_alias_1-expected.txt | 56 +++++++++---------- .../import_all_type_alias-expected.txt | 56 +++++++++---------- .../import_diff_paths-expected.txt | 12 ++-- .../import_extension-expected.txt | 12 ++-- .../import_extension_1-expected.txt | 56 +++++++++---------- .../import_extension_2-expected.txt | 56 +++++++++---------- .../import_function_overload-expected.txt | 12 ++-- .../import_interface_test-expected.txt | 12 ++-- .../import_interface_test_1-expected.txt | 24 ++++---- .../import_interface_test_2-expected.txt | 24 ++++---- .../import_max_as_alias-expected.txt | 12 ++-- .../import_tests/import_name_1-expected.txt | 56 +++++++++---------- .../import_name_alias_1-expected.txt | 56 +++++++++---------- .../imported_module_1-expected.txt | 56 +++++++++---------- .../imported_module_2-expected.txt | 56 +++++++++---------- .../import_relative_path-expected.txt | 56 +++++++++---------- .../import_several_1-expected.txt | 56 +++++++++---------- .../import_several_2-expected.txt | 56 +++++++++---------- .../import_several_3-expected.txt | 56 +++++++++---------- .../import_several_4-expected.txt | 56 +++++++++---------- .../import_several_5-expected.txt | 56 +++++++++---------- .../import_several_6-expected.txt | 56 +++++++++---------- .../import_several_7-expected.txt | 56 +++++++++---------- .../import_tests/import_ts_file-expected.txt | 12 ++-- .../ets/import_tests/internals-expected.txt | 24 ++++---- .../modules/class_default_module-expected.txt | 24 ++++---- .../modules/default_export-expected.txt | 24 ++++---- .../missing_default_export-expected.txt | 24 ++++---- .../module1/src/re_export_file-expected.txt | 24 ++++---- .../module2/src/import_file-expected.txt | 24 ++++---- .../module2/src/re_export_file_2-expected.txt | 24 ++++---- .../modules/test_lib1-expected.txt | 24 ++++---- .../modules/test_lib2-expected.txt | 24 ++++---- .../import1/import1-expected.txt | 12 ++-- .../import2/import2-expected.txt | 12 ++-- .../import_package_with_alias-expected.txt | 12 ++-- .../package/package_module-expected.txt | 44 +++++++-------- .../packages/package_module_1-expected.txt | 12 ++-- .../packages/package_module_2-expected.txt | 12 ++-- .../package_module_1-expected.txt | 44 +++++++-------- .../package_module_1-expected.txt | 44 +++++++-------- .../subpackage/package_module_1-expected.txt | 12 ++-- .../subpackage_module_1-expected.txt | 44 +++++++-------- .../subpackage_module_2-expected.txt | 44 +++++++-------- .../relative_import/Line-expected.txt | 24 ++++---- .../relative_import/Point-expected.txt | 24 ++++---- .../relative_import/alias1-expected.txt | 12 ++-- .../relative_import/alias2-expected.txt | 56 +++++++++---------- .../ets/import_tests/repeat-expected.txt | 24 ++++---- .../folder1/file1-expected.txt | 24 ++++---- .../folder2/file2-expected.txt | 24 ++++---- .../folder3/file3-expected.txt | 24 ++++---- .../ets/import_tests/type/type-expected.txt | 24 ++++---- .../parser/ets/index_expressions-expected.txt | 56 +++++++++---------- ...overriding_method_return_type-expected.txt | 24 ++++---- .../ets/inferingEntryPointReturn-expected.txt | 12 ++-- .../test/parser/ets/inheritance-expected.txt | 24 ++++---- .../test/parser/ets/inheritance2-expected.txt | 12 ++-- .../test/parser/ets/instanceof-expected.txt | 24 ++++---- .../interfaceMethodWithOptional-expected.txt | 24 ++++---- ...ce_abstract_noreturn_function-expected.txt | 24 ++++---- ...interface_method_default_body-expected.txt | 12 ++-- .../test/parser/ets/interfaces-expected.txt | 24 ++++---- .../parser/ets/internalParsing-expected.txt | 12 ++-- .../ets/internalProtectedParsing-expected.txt | 12 ++-- .../ets/labeledDoWhileStatement-expected.txt | 24 ++++---- .../ets/labeledForStatement-expected.txt | 24 ++++---- .../ets/labeledSwitchStatement-expected.txt | 24 ++++---- .../ets/labeledWhileStatement-expected.txt | 24 ++++---- ets2panda/test/parser/ets/lambda-expected.txt | 12 ++-- .../parser/ets/lambda-lambda-expected.txt | 12 ++-- .../lambda-type-inference-alias-expected.txt | 12 ++-- ...da-type-inference-arg-no-type-expected.txt | 12 ++-- .../ets/lambda-type-inference-expected.txt | 12 ++-- ...da-type-inference-no-ret-type-expected.txt | 12 ++-- ...a-type-inference-overloaded-2-expected.txt | 12 ++-- ...a-type-inference-overloaded-3-expected.txt | 24 ++++---- .../ets/lambdaAsFunctionParam-expected.txt | 12 ++-- ...pressionWithoutBlockStatement-expected.txt | 12 ++-- ...ockStatementCallAVoidFunction-expected.txt | 12 ++-- ...sionWithoutBlockStatementVoid-expected.txt | 12 ++-- ...atementWithFunctionParameters-expected.txt | 12 ++-- .../ets/lambdaThrowsRethrows-expected.txt | 56 +++++++++---------- .../ets/lambda_import_alias_1-2-expected.txt | 56 +++++++++---------- .../ets/lambda_import_alias_1-3-expected.txt | 24 ++++---- .../ets/lambda_import_alias_1-expected.txt | 24 ++++---- .../ets/lambda_optional_param_1-expected.txt | 24 ++++---- ets2panda/test/parser/ets/launch-expected.txt | 12 ++-- ...aunch_function_returning_void-expected.txt | 12 ++-- .../test/parser/ets/launch_ret-expected.txt | 12 ++-- .../test/parser/ets/launch_super-expected.txt | 24 ++++---- .../ets/launch_this_callee-expected.txt | 24 ++++---- .../launch_with_call_expression-expected.txt | 56 +++++++++---------- .../test/parser/ets/literals-expected.txt | 24 ++++---- .../test/parser/ets/local-class-expected.txt | 12 ++-- .../parser/ets/local-interface-expected.txt | 12 ++-- .../ets/localClassIsPermitted-expected.txt | 24 ++++---- .../parser/ets/localTypeAlias-expected.txt | 12 ++-- .../ets/main_entry_point_1-expected.txt | 12 ++-- .../ets/main_entry_point_6-expected.txt | 12 ++-- .../ets/main_entry_point_7-expected.txt | 12 ++-- .../ets/main_entry_point_8-expected.txt | 12 ++-- .../ets/main_entry_point_9-expected.txt | 12 ++-- .../ets/methodThrowsRethrows-expected.txt | 24 ++++---- .../test/parser/ets/method_empty-expected.txt | 24 ++++---- .../ets/method_modifier_check_14-expected.txt | 24 ++++---- .../ets/method_modifier_check_8-expected.txt | 24 ++++---- .../ets/method_override_throw_1-expected.txt | 24 ++++---- ...ive_function_with_return_type-expected.txt | 12 ++-- .../parser/ets/new_expressions-expected.txt | 12 ++-- .../test/parser/ets/new_object_3-expected.txt | 12 ++-- ets2panda/test/parser/ets/null-expected.txt | 44 +++++++-------- .../test/parser/ets/null_valid-expected.txt | 56 +++++++++---------- .../ets/nullableGenericSignature-expected.txt | 24 ++++---- .../ets/nullable_union_array-expected.txt | 12 ++-- ets2panda/test/parser/ets/object-expected.txt | 24 ++++---- .../ets/optional_field_class-expected.txt | 24 ++++---- .../ets/optional_field_interface-expected.txt | 24 ++++---- ...optional_field_interfaceUnion-expected.txt | 24 ++++---- .../ets/optional_union_paramter-expected.txt | 12 ++-- .../test/parser/ets/override-expected.txt | 12 ++-- .../ets/overrideStaticFunc-expected.txt | 24 ++++---- .../parentheses_expression_value-expected.txt | 44 +++++++-------- .../parser/ets/predefined_types-expected.txt | 24 ++++---- .../parser/ets/promiseCasting-expected.txt | 44 +++++++-------- .../ets/proxyVoidGeneration-expected.txt | 12 ++-- .../test/parser/ets/proxy_method-expected.txt | 12 ++-- .../ets/re_export/diamond/A-expected.txt | 56 +++++++++---------- .../ets/re_export/diamond/B-expected.txt | 24 ++++---- .../ets/re_export/diamond/B2-expected.txt | 24 ++++---- .../ets/re_export/diamond/C-expected.txt | 24 ++++---- .../ets/re_export/diamond/C2-expected.txt | 24 ++++---- .../ets/re_export/diamond/D-expected.txt | 12 ++-- .../ets/re_export/diamond/D2-expected.txt | 12 ++-- .../parser/ets/re_export/export-expected.txt | 24 ++++---- .../ets/re_export/export_2-expected.txt | 24 ++++---- .../ets/re_export/export_3-expected.txt | 24 ++++---- .../ets/re_export/folder/export-expected.txt | 24 ++++---- .../folder/folder2/export-expected.txt | 24 ++++---- .../re_export/folder/re_export_6-expected.txt | 24 ++++---- .../re_export/folder/re_export_7-expected.txt | 24 ++++---- .../re_export/folderIndex/index-expected.txt | 24 ++++---- .../re_export/folderIndex/test-expected.txt | 24 ++++---- .../re_export/folderIndex2/index-expected.txt | 24 ++++---- .../re_export/folderIndex2/key-expected.txt | 24 ++++---- .../parser/ets/re_export/import-expected.txt | 12 ++-- .../ets/re_export/import_10-expected.txt | 12 ++-- .../ets/re_export/import_11-expected.txt | 12 ++-- .../ets/re_export/import_12-expected.txt | 12 ++-- .../ets/re_export/import_13-expected.txt | 12 ++-- .../ets/re_export/import_14-expected.txt | 12 ++-- .../ets/re_export/import_15-expected.txt | 12 ++-- .../ets/re_export/import_2-expected.txt | 12 ++-- .../ets/re_export/import_3-expected.txt | 12 ++-- .../ets/re_export/import_6-expected.txt | 12 ++-- .../ets/re_export/import_7-expected.txt | 12 ++-- .../ets/re_export/import_8-expected.txt | 12 ++-- .../ets/re_export/import_9-expected.txt | 12 ++-- .../ets/re_export/import_index-expected.txt | 48 ++++++++-------- .../ets/re_export/import_index_2-expected.txt | 48 ++++++++-------- .../ets/re_export/import_index_3-expected.txt | 24 ++++---- .../ets/re_export/re_export-expected.txt | 24 ++++---- .../ets/re_export/re_export_10-expected.txt | 24 ++++---- .../ets/re_export/re_export_11-expected.txt | 24 ++++---- .../ets/re_export/re_export_12-expected.txt | 24 ++++---- .../ets/re_export/re_export_2-expected.txt | 24 ++++---- .../ets/re_export/re_export_3-expected.txt | 24 ++++---- .../ets/re_export/re_export_4-expected.txt | 24 ++++---- .../ets/re_export/re_export_5-expected.txt | 24 ++++---- .../ets/re_export/re_export_7-expected.txt | 24 ++++---- .../ets/re_export/re_export_8-expected.txt | 24 ++++---- .../ets/re_export/re_export_9-expected.txt | 24 ++++---- ...egression-target-type-context-expected.txt | 24 ++++---- .../parser/ets/rest_parameter_01-expected.txt | 24 ++++---- .../parser/ets/rest_parameter_02-expected.txt | 24 ++++---- .../parser/ets/rethrow-func-1-expected.txt | 12 ++-- ets2panda/test/parser/ets/return-expected.txt | 44 +++++++-------- .../returnNullableFromFunction-expected.txt | 24 ++++---- .../ets/returnNullableFromMethod-expected.txt | 24 ++++---- .../test/parser/ets/scoped_decl-expected.txt | 12 ++-- .../selective_export/import_1-expected.txt | 12 ++-- .../selective_export/import_2-expected.txt | 12 ++-- .../selective_export/import_3-expected.txt | 12 ++-- .../selective_export/import_4-expected.txt | 12 ++-- .../selective_export_1-expected.txt | 24 ++++---- .../selective_export_2-expected.txt | 24 ++++---- .../selective_export_3-expected.txt | 24 ++++---- .../selective_export_4-expected.txt | 24 ++++---- .../test/parser/ets/simple_types-expected.txt | 56 +++++++++---------- .../static_function_override_1-expected.txt | 24 ++++---- .../static_function_override_2-expected.txt | 24 ++++---- .../static_function_override_3-expected.txt | 24 ++++---- ets2panda/test/parser/ets/string-expected.txt | 56 +++++++++---------- .../parser/ets/string_template_1-expected.txt | 12 ++-- .../parser/ets/string_template_2-expected.txt | 12 ++-- .../parser/ets/string_template_3-expected.txt | 12 ++-- .../parser/ets/string_template_4-expected.txt | 12 ++-- ets2panda/test/parser/ets/switch-expected.txt | 12 ++-- .../parser/ets/switch_alive_1-expected.txt | 12 ++-- .../parser/ets/switch_alive_4-expected.txt | 24 ++++---- .../ets/switch_enum_string_case-expected.txt | 12 ++-- .../ets/switch_num_compare_char-expected.txt | 12 ++-- .../ets/switch_readonly_member-expected.txt | 12 ++-- ..._readonly_member_compare_char-expected.txt | 12 ++-- ...eadonly_member_compare_char_2-expected.txt | 12 ++-- .../test/parser/ets/ternary-expected.txt | 56 +++++++++---------- .../ets/test-type-alias-call1-expected.txt | 24 ++++---- .../ets/test-type-alias-call2-expected.txt | 24 ++++---- .../ets/test-type-alias-call3-expected.txt | 24 ++++---- .../ets/test-type-alias-call4-expected.txt | 24 ++++---- .../ets/test-type-alias-call5-expected.txt | 24 ++++---- .../ets/test-type-alias-call6-expected.txt | 24 ++++---- .../ets/test-type-alias-call7-expected.txt | 24 ++++---- .../ets/test-type-alias-call8-expected.txt | 24 ++++---- .../parser/ets/test_interface-expected.txt | 24 ++++---- .../test/parser/ets/test_jsvalue-expected.txt | 24 ++++---- .../parser/ets/test_type_alias6-expected.txt | 56 +++++++++---------- .../parser/ets/test_type_alias7-expected.txt | 24 ++++---- .../parser/ets/test_type_alias8-expected.txt | 12 ++-- .../parser/ets/test_type_alias9-expected.txt | 56 +++++++++---------- .../test/parser/ets/this_callee-expected.txt | 24 ++++---- .../parser/ets/this_cmp_object-expected.txt | 24 ++++---- .../parser/ets/this_equality-expected.txt | 24 ++++---- .../parser/ets/this_expression-expected.txt | 24 ++++---- ...ype_class_method_return_valid-expected.txt | 24 ++++---- .../throwsRethrowsAsVariables-expected.txt | 56 +++++++++---------- ..._lambda_define_lambda_in_body-expected.txt | 20 +++---- ...mbda_in_body_capture_variable-expected.txt | 20 +++---- .../trailing_lambda_overload-expected.txt | 36 ++++++------ .../trailing_lambda_overload_1-expected.txt | 20 +++---- ...mbda_transform_trailing_block-expected.txt | 48 ++++++++-------- .../trailing_lambda_type_alias-expected.txt | 14 ++--- .../trailing_lambda_with_throw-expected.txt | 36 ++++++------ .../ets/tryFinallyBlockOnly-expected.txt | 12 ++-- .../parser/ets/tupleAsTypeParam1-expected.txt | 12 ++-- .../parser/ets/tupleAsTypeParam2-expected.txt | 12 ++-- .../ets/tupleIndexWithNumbers-expected.txt | 12 ++-- .../test/parser/ets/type_alias_1-expected.txt | 24 ++++---- .../test/parser/ets/type_alias_2-expected.txt | 24 ++++---- .../test/parser/ets/type_cast-expected.txt | 24 ++++---- .../parser/ets/type_variance1-expected.txt | 24 ++++---- .../test/parser/ets/unary_op-expected.txt | 56 +++++++++---------- .../parser/ets/unary_operations-expected.txt | 24 ++++---- ...finedNullObjectTypeAnnotation-expected.txt | 12 ++-- .../ets/undefinedNullTypeAlias-expected.txt | 12 ++-- ...nion_lowering_common_property-expected.txt | 24 ++++---- .../parser/ets/user_defined_22-expected.txt | 56 +++++++++---------- .../test/parser/ets/var_declare-expected.txt | 24 ++++---- .../variable_throw_function_1-expected.txt | 12 ++-- ets2panda/test/parser/ets/void-expected.txt | 12 ++-- .../parser/ets/voidAsTypeArg-expected.txt | 12 ++-- .../unit/lowerings/top_level_statements.cpp | 25 +++++++++ .../test/unit/lsp/get_touching_token_test.cpp | 4 +- 641 files changed, 7514 insertions(+), 7467 deletions(-) diff --git a/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp b/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp index d35b3eecc0..0f40ccf538 100644 --- a/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp +++ b/ets2panda/compiler/lowering/ets/topLevelStmts/globalClassHandler.cpp @@ -437,7 +437,24 @@ ir::MethodDefinition *GlobalClassHandler::CreateGlobalMethod(const std::string_v auto *methodDef = NodeAllocator::Alloc(allocator_, ir::MethodDefinitionKind::METHOD, ident->Clone(allocator_, nullptr)->AsExpression(), funcExpr, functionModifiers, allocator_, false); - methodDef->SetRange({lexer::SourcePosition(globalProgram_), lexer::SourcePosition(globalProgram_)}); + auto minBound = lexer::SourcePosition(globalProgram_); + auto maxBound = lexer::SourcePosition(globalProgram_); + if (!body->Statements().empty()) { + minBound = body->Statements().front()->Start(); + maxBound = body->Statements().front()->End(); + for (const auto &stmt : body->Statements()) { + if (stmt->Start().index < minBound.index) { + minBound = stmt->Start(); + } + if (stmt->End().index > maxBound.index) { + maxBound = stmt->End(); + } + } + } + body->SetRange({minBound, maxBound}); + func->SetRange({minBound, maxBound}); + funcExpr->SetRange({minBound, maxBound}); + methodDef->SetRange({minBound, maxBound}); return methodDef; } diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp index 65d7398c58..67500b59ac 100644 --- a/ets2panda/parser/expressionParser.cpp +++ b/ets2panda/parser/expressionParser.cpp @@ -1412,6 +1412,9 @@ ir::CallExpression *ParserImpl::ParseCallExpression(ir::Expression *callee, bool if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) { ParseTrailingBlock(callExpr); + if (callExpr->TrailingBlock() != nullptr) { + callExpr->SetRange({callee->Start(), callExpr->TrailingBlock()->End()}); + } return callExpr; } diff --git a/ets2panda/test/compiler/ets/116100-expected.txt b/ets2panda/test/compiler/ets/116100-expected.txt index db59083ea5..3c49933eab 100644 --- a/ets2panda/test/compiler/ets/116100-expected.txt +++ b/ets2panda/test/compiler/ets/116100-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "116100.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "116100.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "116100.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "116100.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "116100.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "116100.ets" } } }, @@ -299,40 +299,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "116100.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 43, + "program": "116100.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "116100.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 43, + "program": "116100.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "116100.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 43, + "program": "116100.ets" } } }, @@ -340,13 +340,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "116100.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 43, "program": "116100.ets" } } diff --git a/ets2panda/test/compiler/ets/ConditionalExpressionCallVoidNeg-expected.txt b/ets2panda/test/compiler/ets/ConditionalExpressionCallVoidNeg-expected.txt index 895378e780..95df6340cd 100644 --- a/ets2panda/test/compiler/ets/ConditionalExpressionCallVoidNeg-expected.txt +++ b/ets2panda/test/compiler/ets/ConditionalExpressionCallVoidNeg-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ConditionalExpressionCallVoidNeg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ConditionalExpressionCallVoidNeg.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ConditionalExpressionCallVoidNeg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ConditionalExpressionCallVoidNeg.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ConditionalExpressionCallVoidNeg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ConditionalExpressionCallVoidNeg.ets" } } }, diff --git a/ets2panda/test/compiler/ets/FunctionType2-expected.txt b/ets2panda/test/compiler/ets/FunctionType2-expected.txt index d38a389d6f..47773f7ec7 100644 --- a/ets2panda/test/compiler/ets/FunctionType2-expected.txt +++ b/ets2panda/test/compiler/ets/FunctionType2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/FunctionType4-expected.txt b/ets2panda/test/compiler/ets/FunctionType4-expected.txt index 025b501c15..e9f5618679 100644 --- a/ets2panda/test/compiler/ets/FunctionType4-expected.txt +++ b/ets2panda/test/compiler/ets/FunctionType4-expected.txt @@ -144,40 +144,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "FunctionType4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 24, + "program": "FunctionType4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "FunctionType4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 24, + "program": "FunctionType4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "FunctionType4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 24, + "program": "FunctionType4.ets" } } }, @@ -185,13 +185,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 20, + "column": 5, "program": "FunctionType4.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 24, "program": "FunctionType4.ets" } } diff --git a/ets2panda/test/compiler/ets/abstractMethodDeclaredInParentClass-expected.txt b/ets2panda/test/compiler/ets/abstractMethodDeclaredInParentClass-expected.txt index 6864a7a181..a2b79ce154 100644 --- a/ets2panda/test/compiler/ets/abstractMethodDeclaredInParentClass-expected.txt +++ b/ets2panda/test/compiler/ets/abstractMethodDeclaredInParentClass-expected.txt @@ -3082,12 +3082,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" } } }, @@ -3095,12 +3095,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" } } }, @@ -3108,12 +3108,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" } } }, @@ -3188,12 +3188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" } } }, @@ -3201,12 +3201,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" } } }, @@ -3214,12 +3214,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractMethodDeclaredInParentClass.ets" } } }, diff --git a/ets2panda/test/compiler/ets/abstractNewClassInstanceExpression-expected.txt b/ets2panda/test/compiler/ets/abstractNewClassInstanceExpression-expected.txt index c9fa2adc08..02f1678229 100644 --- a/ets2panda/test/compiler/ets/abstractNewClassInstanceExpression-expected.txt +++ b/ets2panda/test/compiler/ets/abstractNewClassInstanceExpression-expected.txt @@ -921,12 +921,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractNewClassInstanceExpression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractNewClassInstanceExpression.ets" } } }, @@ -934,12 +934,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractNewClassInstanceExpression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractNewClassInstanceExpression.ets" } } }, @@ -947,12 +947,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "abstractNewClassInstanceExpression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "abstractNewClassInstanceExpression.ets" } } }, @@ -1200,40 +1200,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 32, + "column": 11, + "program": "abstractNewClassInstanceExpression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 35, + "column": 2, + "program": "abstractNewClassInstanceExpression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 32, + "column": 11, + "program": "abstractNewClassInstanceExpression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 35, + "column": 2, + "program": "abstractNewClassInstanceExpression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 32, + "column": 11, + "program": "abstractNewClassInstanceExpression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 35, + "column": 2, + "program": "abstractNewClassInstanceExpression.ets" } } }, @@ -1241,13 +1241,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 32, + "column": 11, "program": "abstractNewClassInstanceExpression.ets" }, "end": { - "line": 1, - "column": 1, + "line": 35, + "column": 2, "program": "abstractNewClassInstanceExpression.ets" } } diff --git a/ets2panda/test/compiler/ets/ambient_declaration-expected.txt b/ets2panda/test/compiler/ets/ambient_declaration-expected.txt index 441653f317..fdab2a6c85 100644 --- a/ets2panda/test/compiler/ets/ambient_declaration-expected.txt +++ b/ets2panda/test/compiler/ets/ambient_declaration-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_declaration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_declaration.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_declaration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_declaration.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_declaration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_declaration.ets" } } }, diff --git a/ets2panda/test/compiler/ets/array_indexing_without_chaining_non_nullish-expected.txt b/ets2panda/test/compiler/ets/array_indexing_without_chaining_non_nullish-expected.txt index ec285695b0..d260612eff 100644 --- a/ets2panda/test/compiler/ets/array_indexing_without_chaining_non_nullish-expected.txt +++ b/ets2panda/test/compiler/ets/array_indexing_without_chaining_non_nullish-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_indexing_without_chaining_non_nullish.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_indexing_without_chaining_non_nullish.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_indexing_without_chaining_non_nullish.ets" } } }, @@ -629,40 +629,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 27, + "program": "array_indexing_without_chaining_non_nullish.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 27, + "program": "array_indexing_without_chaining_non_nullish.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 27, + "program": "array_indexing_without_chaining_non_nullish.ets" } } }, @@ -670,13 +670,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "array_indexing_without_chaining_non_nullish.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 27, "program": "array_indexing_without_chaining_non_nullish.ets" } } diff --git a/ets2panda/test/compiler/ets/array_with_null_type-expected.txt b/ets2panda/test/compiler/ets/array_with_null_type-expected.txt index 3c7d4f477b..61aea179da 100644 --- a/ets2panda/test/compiler/ets/array_with_null_type-expected.txt +++ b/ets2panda/test/compiler/ets/array_with_null_type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_with_null_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_with_null_type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_with_null_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_with_null_type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_with_null_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_with_null_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/array_with_undefined_type-expected.txt b/ets2panda/test/compiler/ets/array_with_undefined_type-expected.txt index 60126b33a7..316fa937e7 100644 --- a/ets2panda/test/compiler/ets/array_with_undefined_type-expected.txt +++ b/ets2panda/test/compiler/ets/array_with_undefined_type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_with_undefined_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_with_undefined_type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_with_undefined_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_with_undefined_type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_with_undefined_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_with_undefined_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/arrowFunctionCapture-expected.txt b/ets2panda/test/compiler/ets/arrowFunctionCapture-expected.txt index 772965af6f..d1bf564e8d 100644 --- a/ets2panda/test/compiler/ets/arrowFunctionCapture-expected.txt +++ b/ets2panda/test/compiler/ets/arrowFunctionCapture-expected.txt @@ -981,12 +981,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" } } }, @@ -994,12 +994,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" } } }, @@ -1007,12 +1007,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" } } }, @@ -1087,12 +1087,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" } } }, @@ -1100,12 +1100,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" } } }, @@ -1113,12 +1113,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrowFunctionCapture.ets" } } }, diff --git a/ets2panda/test/compiler/ets/boxingConversion10-expected.txt b/ets2panda/test/compiler/ets/boxingConversion10-expected.txt index 3dcfcb5693..9026b11d3c 100644 --- a/ets2panda/test/compiler/ets/boxingConversion10-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion10-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion10.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion10.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion10.ets" } } }, @@ -314,40 +314,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion10.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 18, + "program": "boxingConversion10.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion10.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 18, + "program": "boxingConversion10.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion10.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 18, + "program": "boxingConversion10.ets" } } }, @@ -355,13 +355,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boxingConversion10.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 18, "program": "boxingConversion10.ets" } } diff --git a/ets2panda/test/compiler/ets/boxingConversion2-expected.txt b/ets2panda/test/compiler/ets/boxingConversion2-expected.txt index 24f3c862e0..4d8cddd98a 100644 --- a/ets2panda/test/compiler/ets/boxingConversion2-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/boxingConversion3-expected.txt b/ets2panda/test/compiler/ets/boxingConversion3-expected.txt index a8f8673a75..620399e675 100644 --- a/ets2panda/test/compiler/ets/boxingConversion3-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/boxingConversion5-expected.txt b/ets2panda/test/compiler/ets/boxingConversion5-expected.txt index 52a1957148..6217fc4519 100644 --- a/ets2panda/test/compiler/ets/boxingConversion5-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion5-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion5.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion5.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion5.ets" } } }, @@ -444,40 +444,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 18, + "program": "boxingConversion5.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 18, + "program": "boxingConversion5.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 18, + "program": "boxingConversion5.ets" } } }, @@ -485,13 +485,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boxingConversion5.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 18, "program": "boxingConversion5.ets" } } diff --git a/ets2panda/test/compiler/ets/boxingConversion6-expected.txt b/ets2panda/test/compiler/ets/boxingConversion6-expected.txt index 88a8b24639..7b5063ec58 100644 --- a/ets2panda/test/compiler/ets/boxingConversion6-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion6-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion6.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion6.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion6.ets" } } }, @@ -639,40 +639,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 16, + "program": "boxingConversion6.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 16, + "program": "boxingConversion6.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 16, + "program": "boxingConversion6.ets" } } }, @@ -680,13 +680,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boxingConversion6.ets" }, "end": { - "line": 1, - "column": 1, + "line": 22, + "column": 16, "program": "boxingConversion6.ets" } } diff --git a/ets2panda/test/compiler/ets/boxingConversion7-expected.txt b/ets2panda/test/compiler/ets/boxingConversion7-expected.txt index 4ab4be70e0..ed0f15234f 100644 --- a/ets2panda/test/compiler/ets/boxingConversion7-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion7-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion7.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion7.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion7.ets" } } }, @@ -509,40 +509,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion7.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 18, + "program": "boxingConversion7.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion7.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 18, + "program": "boxingConversion7.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion7.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 18, + "program": "boxingConversion7.ets" } } }, @@ -550,13 +550,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boxingConversion7.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 18, "program": "boxingConversion7.ets" } } diff --git a/ets2panda/test/compiler/ets/boxingConversion8-expected.txt b/ets2panda/test/compiler/ets/boxingConversion8-expected.txt index 081b1f8149..cb1abb58a6 100644 --- a/ets2panda/test/compiler/ets/boxingConversion8-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion8-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion8.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion8.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion8.ets" } } }, @@ -509,40 +509,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion8.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 18, + "program": "boxingConversion8.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion8.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 18, + "program": "boxingConversion8.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion8.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 18, + "program": "boxingConversion8.ets" } } }, @@ -550,13 +550,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boxingConversion8.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 18, "program": "boxingConversion8.ets" } } diff --git a/ets2panda/test/compiler/ets/boxingConversion9-expected.txt b/ets2panda/test/compiler/ets/boxingConversion9-expected.txt index ac43037040..6844c681fb 100644 --- a/ets2panda/test/compiler/ets/boxingConversion9-expected.txt +++ b/ets2panda/test/compiler/ets/boxingConversion9-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion9.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion9.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingConversion9.ets" } } }, @@ -379,40 +379,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion9.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 18, + "program": "boxingConversion9.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion9.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 18, + "program": "boxingConversion9.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boxingConversion9.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 18, + "program": "boxingConversion9.ets" } } }, @@ -420,13 +420,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boxingConversion9.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 18, "program": "boxingConversion9.ets" } } diff --git a/ets2panda/test/compiler/ets/boxingUnboxingExpressions-expected.txt b/ets2panda/test/compiler/ets/boxingUnboxingExpressions-expected.txt index ee1717f7c1..b3aab0e5db 100644 --- a/ets2panda/test/compiler/ets/boxingUnboxingExpressions-expected.txt +++ b/ets2panda/test/compiler/ets/boxingUnboxingExpressions-expected.txt @@ -8418,12 +8418,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" } } }, @@ -8431,12 +8431,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" } } }, @@ -8444,12 +8444,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" } } }, @@ -8524,12 +8524,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" } } }, @@ -8537,12 +8537,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" } } }, @@ -8550,12 +8550,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boxingUnboxingExpressions.ets" } } }, diff --git a/ets2panda/test/compiler/ets/catch-soft-keyword-expected.txt b/ets2panda/test/compiler/ets/catch-soft-keyword-expected.txt index 88f8081fd9..00b03aa72a 100644 --- a/ets2panda/test/compiler/ets/catch-soft-keyword-expected.txt +++ b/ets2panda/test/compiler/ets/catch-soft-keyword-expected.txt @@ -511,12 +511,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" } } }, @@ -524,12 +524,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" } } }, @@ -537,12 +537,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" } } }, @@ -617,12 +617,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" } } }, @@ -630,12 +630,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" } } }, @@ -643,12 +643,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catch-soft-keyword.ets" } } }, diff --git a/ets2panda/test/compiler/ets/catchParamScope-expected.txt b/ets2panda/test/compiler/ets/catchParamScope-expected.txt index d0766f9f47..c2a99cefe1 100644 --- a/ets2panda/test/compiler/ets/catchParamScope-expected.txt +++ b/ets2panda/test/compiler/ets/catchParamScope-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catchParamScope.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catchParamScope.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catchParamScope.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catchParamScope.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "catchParamScope.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "catchParamScope.ets" } } }, diff --git a/ets2panda/test/compiler/ets/class_def_varargs_1-expected.txt b/ets2panda/test/compiler/ets/class_def_varargs_1-expected.txt index 44f20b1e6c..3a4ffec7a6 100644 --- a/ets2panda/test/compiler/ets/class_def_varargs_1-expected.txt +++ b/ets2panda/test/compiler/ets/class_def_varargs_1-expected.txt @@ -1047,12 +1047,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" } } }, @@ -1060,12 +1060,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" } } }, @@ -1073,12 +1073,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" } } }, @@ -1153,12 +1153,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" } } }, @@ -1166,12 +1166,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" } } }, @@ -1179,12 +1179,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/class_def_varargs_2-expected.txt b/ets2panda/test/compiler/ets/class_def_varargs_2-expected.txt index ca7e9c33a0..41f57b1707 100644 --- a/ets2panda/test/compiler/ets/class_def_varargs_2-expected.txt +++ b/ets2panda/test/compiler/ets/class_def_varargs_2-expected.txt @@ -395,12 +395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_2.ets" } } }, @@ -408,12 +408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_2.ets" } } }, @@ -421,12 +421,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_def_varargs_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/conversion-w-ASExpr-expected.txt b/ets2panda/test/compiler/ets/conversion-w-ASExpr-expected.txt index be4ca35299..72fa0ee403 100644 --- a/ets2panda/test/compiler/ets/conversion-w-ASExpr-expected.txt +++ b/ets2panda/test/compiler/ets/conversion-w-ASExpr-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversion-w-ASExpr.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversion-w-ASExpr.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversion-w-ASExpr.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversion-w-ASExpr.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversion-w-ASExpr.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversion-w-ASExpr.ets" } } }, diff --git a/ets2panda/test/compiler/ets/conversion_w_functions-expected.txt b/ets2panda/test/compiler/ets/conversion_w_functions-expected.txt index 561d477e9a..ecd5166add 100644 --- a/ets2panda/test/compiler/ets/conversion_w_functions-expected.txt +++ b/ets2panda/test/compiler/ets/conversion_w_functions-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversion_w_functions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversion_w_functions.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversion_w_functions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversion_w_functions.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversion_w_functions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversion_w_functions.ets" } } }, diff --git a/ets2panda/test/compiler/ets/delete-non-keyword-expected.txt b/ets2panda/test/compiler/ets/delete-non-keyword-expected.txt index 61c9e38752..29cda5aafe 100644 --- a/ets2panda/test/compiler/ets/delete-non-keyword-expected.txt +++ b/ets2panda/test/compiler/ets/delete-non-keyword-expected.txt @@ -423,12 +423,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" } } }, @@ -436,12 +436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" } } }, @@ -449,12 +449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" } } }, @@ -529,12 +529,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" } } }, @@ -542,12 +542,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" } } }, @@ -555,12 +555,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "delete-non-keyword.ets" } } }, diff --git a/ets2panda/test/compiler/ets/ensureNotNullArgNotNullable-expected.txt b/ets2panda/test/compiler/ets/ensureNotNullArgNotNullable-expected.txt index e8bdf6bfde..d7785640f8 100644 --- a/ets2panda/test/compiler/ets/ensureNotNullArgNotNullable-expected.txt +++ b/ets2panda/test/compiler/ets/ensureNotNullArgNotNullable-expected.txt @@ -191,12 +191,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullArgNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullArgNotNullable.ets" } } }, @@ -204,12 +204,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullArgNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullArgNotNullable.ets" } } }, @@ -217,12 +217,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullArgNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullArgNotNullable.ets" } } }, diff --git a/ets2panda/test/compiler/ets/ensureNotNullLocalNotNullable-expected.txt b/ets2panda/test/compiler/ets/ensureNotNullLocalNotNullable-expected.txt index 6baa69fe84..780a6c73b8 100644 --- a/ets2panda/test/compiler/ets/ensureNotNullLocalNotNullable-expected.txt +++ b/ets2panda/test/compiler/ets/ensureNotNullLocalNotNullable-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullLocalNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullLocalNotNullable.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullLocalNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullLocalNotNullable.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullLocalNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullLocalNotNullable.ets" } } }, diff --git a/ets2panda/test/compiler/ets/ensureNotNullReturnNotNullable-expected.txt b/ets2panda/test/compiler/ets/ensureNotNullReturnNotNullable-expected.txt index 28be07a026..0d0389239b 100644 --- a/ets2panda/test/compiler/ets/ensureNotNullReturnNotNullable-expected.txt +++ b/ets2panda/test/compiler/ets/ensureNotNullReturnNotNullable-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullReturnNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullReturnNotNullable.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullReturnNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullReturnNotNullable.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullReturnNotNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ensureNotNullReturnNotNullable.ets" } } }, diff --git a/ets2panda/test/compiler/ets/enum_as_class_member_getValue_call-expected.txt b/ets2panda/test/compiler/ets/enum_as_class_member_getValue_call-expected.txt index 2fd3325638..1540edf473 100644 --- a/ets2panda/test/compiler/ets/enum_as_class_member_getValue_call-expected.txt +++ b/ets2panda/test/compiler/ets/enum_as_class_member_getValue_call-expected.txt @@ -11439,12 +11439,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" } } }, @@ -11452,12 +11452,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" } } }, @@ -11465,12 +11465,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" } } }, @@ -11545,12 +11545,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" } } }, @@ -11558,12 +11558,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" } } }, @@ -11571,12 +11571,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_as_class_member_getValue_call.ets" } } }, diff --git a/ets2panda/test/compiler/ets/export_type-expected.txt b/ets2panda/test/compiler/ets/export_type-expected.txt index cd258876a3..28f42dc576 100644 --- a/ets2panda/test/compiler/ets/export_type-expected.txt +++ b/ets2panda/test/compiler/ets/export_type-expected.txt @@ -594,12 +594,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" } } }, @@ -607,12 +607,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" } } }, @@ -620,12 +620,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" } } }, @@ -700,12 +700,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" } } }, @@ -713,12 +713,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" } } }, @@ -726,12 +726,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt b/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt index ff6a2de361..81df745797 100644 --- a/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt +++ b/ets2panda/test/compiler/ets/extended_conditional_expression_not-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not.ets" } } }, diff --git a/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt b/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt index aa0afff24d..5625d26670 100644 --- a/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt +++ b/ets2panda/test/compiler/ets/extended_conditional_expression_not_return_type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extended_conditional_expression_not_return_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/forUpdate-expected.txt b/ets2panda/test/compiler/ets/forUpdate-expected.txt index e5bcb79a17..3152e96841 100644 --- a/ets2panda/test/compiler/ets/forUpdate-expected.txt +++ b/ets2panda/test/compiler/ets/forUpdate-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdate.ets" } } }, diff --git a/ets2panda/test/compiler/ets/forUpdateCharType-expected.txt b/ets2panda/test/compiler/ets/forUpdateCharType-expected.txt index ad727281be..a1126a66ef 100644 --- a/ets2panda/test/compiler/ets/forUpdateCharType-expected.txt +++ b/ets2panda/test/compiler/ets/forUpdateCharType-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdateCharType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdateCharType.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdateCharType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdateCharType.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forUpdateCharType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forUpdateCharType.ets" } } }, diff --git a/ets2panda/test/compiler/ets/from-soft-keyword-0-expected.txt b/ets2panda/test/compiler/ets/from-soft-keyword-0-expected.txt index 04b2dfe4ae..25fda0730c 100644 --- a/ets2panda/test/compiler/ets/from-soft-keyword-0-expected.txt +++ b/ets2panda/test/compiler/ets/from-soft-keyword-0-expected.txt @@ -631,12 +631,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-0.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-0.ets" } } }, @@ -644,12 +644,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-0.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-0.ets" } } }, @@ -657,12 +657,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-0.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-0.ets" } } }, diff --git a/ets2panda/test/compiler/ets/from-soft-keyword-1-expected.txt b/ets2panda/test/compiler/ets/from-soft-keyword-1-expected.txt index a72b40f301..1ac22e9228 100644 --- a/ets2panda/test/compiler/ets/from-soft-keyword-1-expected.txt +++ b/ets2panda/test/compiler/ets/from-soft-keyword-1-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-1.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-1.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/from-soft-keyword-2-expected.txt b/ets2panda/test/compiler/ets/from-soft-keyword-2-expected.txt index 3e6e2e5a19..f55018cd67 100644 --- a/ets2panda/test/compiler/ets/from-soft-keyword-2-expected.txt +++ b/ets2panda/test/compiler/ets/from-soft-keyword-2-expected.txt @@ -348,12 +348,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-2.ets" } } }, @@ -361,12 +361,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-2.ets" } } }, @@ -374,12 +374,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "from-soft-keyword-2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/func-ref-private-expected.txt b/ets2panda/test/compiler/ets/func-ref-private-expected.txt index 42e551d9da..37bf0bf103 100644 --- a/ets2panda/test/compiler/ets/func-ref-private-expected.txt +++ b/ets2panda/test/compiler/ets/func-ref-private-expected.txt @@ -595,12 +595,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" } } }, @@ -608,12 +608,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" } } }, @@ -621,12 +621,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" } } }, @@ -701,12 +701,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" } } }, @@ -714,12 +714,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" } } }, @@ -727,12 +727,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "func-ref-private.ets" } } }, diff --git a/ets2panda/test/compiler/ets/functionPointerArray-expected.txt b/ets2panda/test/compiler/ets/functionPointerArray-expected.txt index 8d17c39ba7..94b9bcf948 100644 --- a/ets2panda/test/compiler/ets/functionPointerArray-expected.txt +++ b/ets2panda/test/compiler/ets/functionPointerArray-expected.txt @@ -143,12 +143,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionPointerArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionPointerArray.ets" } } }, @@ -156,12 +156,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionPointerArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionPointerArray.ets" } } }, @@ -169,12 +169,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionPointerArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionPointerArray.ets" } } }, diff --git a/ets2panda/test/compiler/ets/functionTypeToObject-expected.txt b/ets2panda/test/compiler/ets/functionTypeToObject-expected.txt index bb46138b3a..a3009be512 100644 --- a/ets2panda/test/compiler/ets/functionTypeToObject-expected.txt +++ b/ets2panda/test/compiler/ets/functionTypeToObject-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeToObject.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeToObject.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeToObject.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeToObject.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeToObject.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeToObject.ets" } } }, diff --git a/ets2panda/test/compiler/ets/function_subtyping_1-expected.txt b/ets2panda/test/compiler/ets/function_subtyping_1-expected.txt index 6773ef4311..bb165494d6 100644 --- a/ets2panda/test/compiler/ets/function_subtyping_1-expected.txt +++ b/ets2panda/test/compiler/ets/function_subtyping_1-expected.txt @@ -436,12 +436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_subtyping_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_subtyping_1.ets" } } }, @@ -449,12 +449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_subtyping_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_subtyping_1.ets" } } }, @@ -462,12 +462,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_subtyping_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_subtyping_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/functions_with_ambiguous_rest_parameter-expected.txt b/ets2panda/test/compiler/ets/functions_with_ambiguous_rest_parameter-expected.txt index 74d45b5f1b..062eb8492b 100644 --- a/ets2panda/test/compiler/ets/functions_with_ambiguous_rest_parameter-expected.txt +++ b/ets2panda/test/compiler/ets/functions_with_ambiguous_rest_parameter-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functions_with_ambiguous_rest_parameter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functions_with_ambiguous_rest_parameter.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functions_with_ambiguous_rest_parameter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functions_with_ambiguous_rest_parameter.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functions_with_ambiguous_rest_parameter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functions_with_ambiguous_rest_parameter.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_arrayaslist-expected.txt b/ets2panda/test/compiler/ets/generic_arrayaslist-expected.txt index dbc3587397..2593686b4e 100644 --- a/ets2panda/test/compiler/ets/generic_arrayaslist-expected.txt +++ b/ets2panda/test/compiler/ets/generic_arrayaslist-expected.txt @@ -25246,12 +25246,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" } } }, @@ -25259,12 +25259,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" } } }, @@ -25272,12 +25272,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" } } }, @@ -25352,12 +25352,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" } } }, @@ -25365,12 +25365,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" } } }, @@ -25378,12 +25378,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_arrayaslist.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_class_getter_setter-expected.txt b/ets2panda/test/compiler/ets/generic_class_getter_setter-expected.txt index fb6cf3a2db..753829ff6e 100644 --- a/ets2panda/test/compiler/ets/generic_class_getter_setter-expected.txt +++ b/ets2panda/test/compiler/ets/generic_class_getter_setter-expected.txt @@ -656,12 +656,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_class_getter_setter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_class_getter_setter.ets" } } }, @@ -669,12 +669,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_class_getter_setter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_class_getter_setter.ets" } } }, @@ -682,12 +682,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_class_getter_setter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_class_getter_setter.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_deadlock-expected.txt b/ets2panda/test/compiler/ets/generic_deadlock-expected.txt index 8892d6af0d..7e0bce2638 100644 --- a/ets2panda/test/compiler/ets/generic_deadlock-expected.txt +++ b/ets2panda/test/compiler/ets/generic_deadlock-expected.txt @@ -935,12 +935,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_deadlock.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_deadlock.ets" } } }, @@ -948,12 +948,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_deadlock.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_deadlock.ets" } } }, @@ -961,12 +961,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_deadlock.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_deadlock.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_func_rest_param_spread_infer-expected.txt b/ets2panda/test/compiler/ets/generic_func_rest_param_spread_infer-expected.txt index d5764ab4a6..7df4fb223a 100644 --- a/ets2panda/test/compiler/ets/generic_func_rest_param_spread_infer-expected.txt +++ b/ets2panda/test/compiler/ets/generic_func_rest_param_spread_infer-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_func_rest_param_spread_infer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_func_rest_param_spread_infer.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_func_rest_param_spread_infer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_func_rest_param_spread_infer.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_func_rest_param_spread_infer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_func_rest_param_spread_infer.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_function_call_1-expected.txt b/ets2panda/test/compiler/ets/generic_function_call_1-expected.txt index 103caf2507..9e5c24ccf8 100644 --- a/ets2panda/test/compiler/ets/generic_function_call_1-expected.txt +++ b/ets2panda/test/compiler/ets/generic_function_call_1-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_1.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_1.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_function_call_3-expected.txt b/ets2panda/test/compiler/ets/generic_function_call_3-expected.txt index 38a6336d53..d0c98d2a9a 100644 --- a/ets2panda/test/compiler/ets/generic_function_call_3-expected.txt +++ b/ets2panda/test/compiler/ets/generic_function_call_3-expected.txt @@ -436,12 +436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_3.ets" } } }, @@ -449,12 +449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_3.ets" } } }, @@ -462,12 +462,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_function_call_4-expected.txt b/ets2panda/test/compiler/ets/generic_function_call_4-expected.txt index 59b93fd893..4c26e04289 100644 --- a/ets2panda/test/compiler/ets/generic_function_call_4-expected.txt +++ b/ets2panda/test/compiler/ets/generic_function_call_4-expected.txt @@ -439,12 +439,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_4.ets" } } }, @@ -452,12 +452,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_4.ets" } } }, @@ -465,12 +465,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_4.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_function_call_5-expected.txt b/ets2panda/test/compiler/ets/generic_function_call_5-expected.txt index 419f8fd9d5..f2e28c4500 100644 --- a/ets2panda/test/compiler/ets/generic_function_call_5-expected.txt +++ b/ets2panda/test/compiler/ets/generic_function_call_5-expected.txt @@ -644,12 +644,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" } } }, @@ -657,12 +657,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" } } }, @@ -670,12 +670,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" } } }, @@ -750,12 +750,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" } } }, @@ -763,12 +763,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" } } }, @@ -776,12 +776,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_5.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_function_call_7-expected.txt b/ets2panda/test/compiler/ets/generic_function_call_7-expected.txt index f9f6b3bff3..074c3a749d 100644 --- a/ets2panda/test/compiler/ets/generic_function_call_7-expected.txt +++ b/ets2panda/test/compiler/ets/generic_function_call_7-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_7.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_7.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function_call_7.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_override_1-expected.txt b/ets2panda/test/compiler/ets/generic_override_1-expected.txt index 4a34e9a646..1aefaac659 100644 --- a/ets2panda/test/compiler/ets/generic_override_1-expected.txt +++ b/ets2panda/test/compiler/ets/generic_override_1-expected.txt @@ -2412,12 +2412,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" } } }, @@ -2425,12 +2425,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" } } }, @@ -2438,12 +2438,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" } } }, @@ -2518,12 +2518,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" } } }, @@ -2531,12 +2531,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" } } }, @@ -2544,12 +2544,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_override_2-expected.txt b/ets2panda/test/compiler/ets/generic_override_2-expected.txt index c2dbfd36a3..fb2c29a366 100644 --- a/ets2panda/test/compiler/ets/generic_override_2-expected.txt +++ b/ets2panda/test/compiler/ets/generic_override_2-expected.txt @@ -3041,12 +3041,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" } } }, @@ -3054,12 +3054,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" } } }, @@ -3067,12 +3067,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" } } }, @@ -3147,12 +3147,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" } } }, @@ -3160,12 +3160,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" } } }, @@ -3173,12 +3173,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_override_3-expected.txt b/ets2panda/test/compiler/ets/generic_override_3-expected.txt index 2d4cfb7f0b..bc1446ac5d 100644 --- a/ets2panda/test/compiler/ets/generic_override_3-expected.txt +++ b/ets2panda/test/compiler/ets/generic_override_3-expected.txt @@ -2321,12 +2321,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" } } }, @@ -2334,12 +2334,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" } } }, @@ -2347,12 +2347,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" } } }, @@ -2427,12 +2427,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" } } }, @@ -2440,12 +2440,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" } } }, @@ -2453,12 +2453,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_override_3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_typealias_1-expected.txt b/ets2panda/test/compiler/ets/generic_typealias_1-expected.txt index bb55e4fe01..a4235a75e5 100644 --- a/ets2panda/test/compiler/ets/generic_typealias_1-expected.txt +++ b/ets2panda/test/compiler/ets/generic_typealias_1-expected.txt @@ -683,12 +683,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_1.ets" } } }, @@ -696,12 +696,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_1.ets" } } }, @@ -709,12 +709,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_typealias_6-expected.txt b/ets2panda/test/compiler/ets/generic_typealias_6-expected.txt index b48772350b..3cb0c9580f 100644 --- a/ets2panda/test/compiler/ets/generic_typealias_6-expected.txt +++ b/ets2panda/test/compiler/ets/generic_typealias_6-expected.txt @@ -587,12 +587,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_6.ets" } } }, @@ -600,12 +600,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_6.ets" } } }, @@ -613,12 +613,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_6.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_typealias_7_neg-expected.txt b/ets2panda/test/compiler/ets/generic_typealias_7_neg-expected.txt index 8f6727aa4f..b67e9bdf21 100644 --- a/ets2panda/test/compiler/ets/generic_typealias_7_neg-expected.txt +++ b/ets2panda/test/compiler/ets/generic_typealias_7_neg-expected.txt @@ -208,12 +208,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_7_neg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_7_neg.ets" } } }, @@ -221,12 +221,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_7_neg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_7_neg.ets" } } }, @@ -234,12 +234,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_7_neg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_7_neg.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_typealias_8-expected.txt b/ets2panda/test/compiler/ets/generic_typealias_8-expected.txt index fc2c7877a2..4f2a59a9b9 100644 --- a/ets2panda/test/compiler/ets/generic_typealias_8-expected.txt +++ b/ets2panda/test/compiler/ets/generic_typealias_8-expected.txt @@ -363,12 +363,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_8.ets" } } }, @@ -376,12 +376,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_8.ets" } } }, @@ -389,12 +389,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_8.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_typealias_9-expected.txt b/ets2panda/test/compiler/ets/generic_typealias_9-expected.txt index ee67f2d5ef..4192403c56 100644 --- a/ets2panda/test/compiler/ets/generic_typealias_9-expected.txt +++ b/ets2panda/test/compiler/ets/generic_typealias_9-expected.txt @@ -272,12 +272,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_9.ets" } } }, @@ -285,12 +285,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_9.ets" } } }, @@ -298,12 +298,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_9.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generic_variance_1-expected.txt b/ets2panda/test/compiler/ets/generic_variance_1-expected.txt index 3fd3bc2906..4e142e0137 100644 --- a/ets2panda/test/compiler/ets/generic_variance_1-expected.txt +++ b/ets2panda/test/compiler/ets/generic_variance_1-expected.txt @@ -846,12 +846,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_variance_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_variance_1.ets" } } }, @@ -859,12 +859,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_variance_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_variance_1.ets" } } }, @@ -872,12 +872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_variance_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_variance_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_class_recursive_type_1-expected.txt b/ets2panda/test/compiler/ets/generics_class_recursive_type_1-expected.txt index 15455cf8ca..87c129fa61 100644 --- a/ets2panda/test/compiler/ets/generics_class_recursive_type_1-expected.txt +++ b/ets2panda/test/compiler/ets/generics_class_recursive_type_1-expected.txt @@ -8326,12 +8326,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" } } }, @@ -8339,12 +8339,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" } } }, @@ -8352,12 +8352,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" } } }, @@ -8432,12 +8432,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" } } }, @@ -8445,12 +8445,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" } } }, @@ -8458,12 +8458,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_class_recursive_type_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_implicit_lambda1-expected.txt b/ets2panda/test/compiler/ets/generics_implicit_lambda1-expected.txt index 8aad3e19bf..ded3411769 100644 --- a/ets2panda/test/compiler/ets/generics_implicit_lambda1-expected.txt +++ b/ets2panda/test/compiler/ets/generics_implicit_lambda1-expected.txt @@ -1289,12 +1289,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_implicit_lambda1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_implicit_lambda1.ets" } } }, @@ -1302,12 +1302,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_implicit_lambda1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_implicit_lambda1.ets" } } }, @@ -1315,12 +1315,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_implicit_lambda1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_implicit_lambda1.ets" } } }, @@ -2391,7 +2391,7 @@ "program": "generics_implicit_lambda1.ets" }, "end": { - "line": 42, + "line": 43, "column": 6, "program": "generics_implicit_lambda1.ets" } @@ -2404,7 +2404,7 @@ "program": "generics_implicit_lambda1.ets" }, "end": { - "line": 42, + "line": 43, "column": 6, "program": "generics_implicit_lambda1.ets" } diff --git a/ets2panda/test/compiler/ets/generics_instantiation_1-expected.txt b/ets2panda/test/compiler/ets/generics_instantiation_1-expected.txt index 311c0e2a9d..7162f7a434 100644 --- a/ets2panda/test/compiler/ets/generics_instantiation_1-expected.txt +++ b/ets2panda/test/compiler/ets/generics_instantiation_1-expected.txt @@ -2364,12 +2364,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" } } }, @@ -2377,12 +2377,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" } } }, @@ -2390,12 +2390,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" } } }, @@ -2470,12 +2470,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" } } }, @@ -2483,12 +2483,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" } } }, @@ -2496,12 +2496,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_instantiation_2-expected.txt b/ets2panda/test/compiler/ets/generics_instantiation_2-expected.txt index 43a0768251..86c5ee5895 100644 --- a/ets2panda/test/compiler/ets/generics_instantiation_2-expected.txt +++ b/ets2panda/test/compiler/ets/generics_instantiation_2-expected.txt @@ -1467,12 +1467,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" } } }, @@ -1480,12 +1480,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" } } }, @@ -1493,12 +1493,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" } } }, @@ -1573,12 +1573,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" } } }, @@ -1586,12 +1586,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" } } }, @@ -1599,12 +1599,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_instantiation_3-expected.txt b/ets2panda/test/compiler/ets/generics_instantiation_3-expected.txt index ce99ae1ff2..7429ca1722 100644 --- a/ets2panda/test/compiler/ets/generics_instantiation_3-expected.txt +++ b/ets2panda/test/compiler/ets/generics_instantiation_3-expected.txt @@ -830,12 +830,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" } } }, @@ -843,12 +843,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" } } }, @@ -856,12 +856,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" } } }, @@ -936,12 +936,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" } } }, @@ -949,12 +949,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" } } }, @@ -962,12 +962,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_instantiation_4-expected.txt b/ets2panda/test/compiler/ets/generics_instantiation_4-expected.txt index 88921ffe6d..11f31c14a4 100644 --- a/ets2panda/test/compiler/ets/generics_instantiation_4-expected.txt +++ b/ets2panda/test/compiler/ets/generics_instantiation_4-expected.txt @@ -2504,12 +2504,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" } } }, @@ -2517,12 +2517,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" } } }, @@ -2530,12 +2530,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" } } }, @@ -2610,12 +2610,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" } } }, @@ -2623,12 +2623,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" } } }, @@ -2636,12 +2636,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_instantiation_4.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_interface_bounds_1-expected.txt b/ets2panda/test/compiler/ets/generics_interface_bounds_1-expected.txt index 41648a6b9e..94e3b11b8d 100644 --- a/ets2panda/test/compiler/ets/generics_interface_bounds_1-expected.txt +++ b/ets2panda/test/compiler/ets/generics_interface_bounds_1-expected.txt @@ -1213,12 +1213,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" } } }, @@ -1226,12 +1226,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" } } }, @@ -1239,12 +1239,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" } } }, @@ -1319,12 +1319,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" } } }, @@ -1332,12 +1332,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" } } }, @@ -1345,12 +1345,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_interface_bounds_2-expected.txt b/ets2panda/test/compiler/ets/generics_interface_bounds_2-expected.txt index 07b6fb741b..59a5dffb4e 100644 --- a/ets2panda/test/compiler/ets/generics_interface_bounds_2-expected.txt +++ b/ets2panda/test/compiler/ets/generics_interface_bounds_2-expected.txt @@ -385,12 +385,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" } } }, @@ -398,12 +398,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" } } }, @@ -411,12 +411,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" } } }, @@ -491,12 +491,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" } } }, @@ -504,12 +504,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" } } }, @@ -517,12 +517,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_interface_bounds_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/generics_primitive_type_param_1-expected.txt b/ets2panda/test/compiler/ets/generics_primitive_type_param_1-expected.txt index bb1de93228..ffa5c10970 100644 --- a/ets2panda/test/compiler/ets/generics_primitive_type_param_1-expected.txt +++ b/ets2panda/test/compiler/ets/generics_primitive_type_param_1-expected.txt @@ -442,12 +442,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" } } }, @@ -455,12 +455,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" } } }, @@ -468,12 +468,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" } } }, @@ -548,12 +548,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" } } }, @@ -561,12 +561,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" } } }, @@ -574,12 +574,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_primitive_type_param_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/identifierReference14-expected.txt b/ets2panda/test/compiler/ets/identifierReference14-expected.txt index f0b7ebecc1..e0f435c79b 100644 --- a/ets2panda/test/compiler/ets/identifierReference14-expected.txt +++ b/ets2panda/test/compiler/ets/identifierReference14-expected.txt @@ -961,12 +961,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" } } }, @@ -974,12 +974,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" } } }, @@ -987,12 +987,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" } } }, @@ -1067,12 +1067,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" } } }, @@ -1080,12 +1080,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" } } }, @@ -1093,12 +1093,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference14.ets" } } }, diff --git a/ets2panda/test/compiler/ets/identifierReference4-expected.txt b/ets2panda/test/compiler/ets/identifierReference4-expected.txt index 5ca765a6cc..4b321f925a 100644 --- a/ets2panda/test/compiler/ets/identifierReference4-expected.txt +++ b/ets2panda/test/compiler/ets/identifierReference4-expected.txt @@ -725,12 +725,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference4.ets" } } }, @@ -738,12 +738,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference4.ets" } } }, @@ -751,12 +751,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifierReference4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifierReference4.ets" } } }, @@ -894,40 +894,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "identifierReference4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 16, + "program": "identifierReference4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "identifierReference4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 16, + "program": "identifierReference4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "identifierReference4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 16, + "program": "identifierReference4.ets" } } }, @@ -935,13 +935,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "identifierReference4.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 16, "program": "identifierReference4.ets" } } diff --git a/ets2panda/test/compiler/ets/implicit-conversion-expected.txt b/ets2panda/test/compiler/ets/implicit-conversion-expected.txt index 6ec3601199..96591dd8a0 100644 --- a/ets2panda/test/compiler/ets/implicit-conversion-expected.txt +++ b/ets2panda/test/compiler/ets/implicit-conversion-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "implicit-conversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "implicit-conversion.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "implicit-conversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "implicit-conversion.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "implicit-conversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "implicit-conversion.ets" } } }, diff --git a/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_1-expected.txt b/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_1-expected.txt index 221888de53..9088eefd25 100644 --- a/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_1-expected.txt +++ b/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_1-expected.txt @@ -645,40 +645,40 @@ ], "loc": { "start": { - "line": 1, + "line": 19, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 25, + "program": "package_module_2.ets" } } }, "loc": { "start": { - "line": 1, + "line": 19, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 25, + "program": "package_module_2.ets" } } }, "loc": { "start": { - "line": 1, + "line": 19, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 25, + "program": "package_module_2.ets" } } }, @@ -686,14 +686,14 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 19, "column": 1, - "program": "package_module_1.ets" + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": "package_module_1.ets" + "line": 20, + "column": 25, + "program": "package_module_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_2-expected.txt b/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_2-expected.txt index 798f662e62..4a7b7b6d6f 100644 --- a/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_2-expected.txt +++ b/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/package_module_2-expected.txt @@ -645,40 +645,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 20, + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 17, + "program": "package_module_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 20, + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 17, + "program": "package_module_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 20, + "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 17, + "program": "package_module_2.ets" } } }, @@ -686,13 +686,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 20, "program": "package_module_2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 17, "program": "package_module_2.ets" } } diff --git a/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/separate_module_1-expected.txt b/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/separate_module_1-expected.txt index 3468422f01..ce069d891f 100644 --- a/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/separate_module_1-expected.txt +++ b/ets2panda/test/compiler/ets/implicit_package_import/package_test_1/separate_module_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 34, + "program": "separate_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 34, + "program": "separate_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 34, + "program": "separate_module_1.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 34, "program": "separate_module_1.ets" } } diff --git a/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_1-expected.txt b/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_1-expected.txt index 57744f20ac..4b6dcadf6c 100644 --- a/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_1-expected.txt +++ b/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_1-expected.txt @@ -432,12 +432,12 @@ "start": { "line": 1, "column": 1, - "program": "package_module_1.ets" + "program": null }, "end": { "line": 1, "column": 1, - "program": "package_module_1.ets" + "program": null } } }, @@ -497,12 +497,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, @@ -510,12 +510,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, @@ -523,12 +523,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_2-expected.txt b/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_2-expected.txt index 28e77ee934..b2196585c2 100644 --- a/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_2-expected.txt +++ b/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_1/package_module_2-expected.txt @@ -432,12 +432,12 @@ "start": { "line": 1, "column": 1, - "program": "package_module_2.ets" + "program": null }, "end": { "line": 1, "column": 1, - "program": "package_module_2.ets" + "program": null } } }, @@ -497,12 +497,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" } } }, @@ -510,12 +510,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" } } }, @@ -523,12 +523,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_2/separate_module_1-expected.txt b/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_2/separate_module_1-expected.txt index baacd60da4..e4917aa097 100644 --- a/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_2/separate_module_1-expected.txt +++ b/ets2panda/test/compiler/ets/implicit_package_import/package_test_2/subpackage_2/separate_module_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module_1.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 29, + "program": "separate_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 29, + "program": "separate_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 29, + "program": "separate_module_1.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "separate_module_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 29, "program": "separate_module_1.ets" } } diff --git a/ets2panda/test/compiler/ets/import_tests/asyncfun_lambda_lib-expected.txt b/ets2panda/test/compiler/ets/import_tests/asyncfun_lambda_lib-expected.txt index 61cf0f6153..3c874f399f 100644 --- a/ets2panda/test/compiler/ets/import_tests/asyncfun_lambda_lib-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/asyncfun_lambda_lib-expected.txt @@ -1505,12 +1505,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" } } }, @@ -1518,12 +1518,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" } } }, @@ -1531,12 +1531,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" } } }, @@ -1611,12 +1611,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" } } }, @@ -1624,12 +1624,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" } } }, @@ -1637,12 +1637,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfun_lambda_lib.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/asyncfunc_lambda_main-expected.txt b/ets2panda/test/compiler/ets/import_tests/asyncfunc_lambda_main-expected.txt index 1a6536528c..0a3c93a371 100644 --- a/ets2panda/test/compiler/ets/import_tests/asyncfunc_lambda_main-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/asyncfunc_lambda_main-expected.txt @@ -408,12 +408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfunc_lambda_main.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfunc_lambda_main.ets" } } }, @@ -421,12 +421,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfunc_lambda_main.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfunc_lambda_main.ets" } } }, @@ -434,12 +434,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "asyncfunc_lambda_main.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "asyncfunc_lambda_main.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/enum_export-expected.txt b/ets2panda/test/compiler/ets/import_tests/enum_export-expected.txt index 4cc17d4052..5c2bf9184d 100644 --- a/ets2panda/test/compiler/ets/import_tests/enum_export-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/enum_export-expected.txt @@ -12753,12 +12753,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" } } }, @@ -12766,12 +12766,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" } } }, @@ -12779,12 +12779,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" } } }, @@ -12859,12 +12859,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" } } }, @@ -12872,12 +12872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" } } }, @@ -12885,12 +12885,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_export.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/enum_import-expected.txt b/ets2panda/test/compiler/ets/import_tests/enum_import-expected.txt index 234229fd33..6c36670b03 100644 --- a/ets2panda/test/compiler/ets/import_tests/enum_import-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/enum_import-expected.txt @@ -260,12 +260,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_import.ets" } } }, @@ -273,12 +273,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_import.ets" } } }, @@ -286,12 +286,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "enum_import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "enum_import.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/export_class_with_getters_setters-expected.txt b/ets2panda/test/compiler/ets/import_tests/export_class_with_getters_setters-expected.txt index 0ff68cff92..5259630c36 100644 --- a/ets2panda/test/compiler/ets/import_tests/export_class_with_getters_setters-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/export_class_with_getters_setters-expected.txt @@ -961,12 +961,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" } } }, @@ -974,12 +974,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" } } }, @@ -987,12 +987,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" } } }, @@ -1067,12 +1067,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" } } }, @@ -1080,12 +1080,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" } } }, @@ -1093,12 +1093,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_class_with_getters_setters.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type-expected.txt b/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type-expected.txt index 67e4ebce20..2726b422af 100644 --- a/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type_lib-expected.txt b/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type_lib-expected.txt index 4c0d8a449b..6b6704bf23 100644 --- a/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type_lib-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/generic_typealias_func_type_lib-expected.txt @@ -336,12 +336,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" } } }, @@ -349,12 +349,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" } } }, @@ -362,12 +362,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" } } }, @@ -442,12 +442,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" } } }, @@ -455,12 +455,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" } } }, @@ -468,12 +468,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_typealias_func_type_lib.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/import_class_with_getters_setters-expected.txt b/ets2panda/test/compiler/ets/import_tests/import_class_with_getters_setters-expected.txt index 20e7f03505..831bf3e6e7 100644 --- a/ets2panda/test/compiler/ets/import_tests/import_class_with_getters_setters-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/import_class_with_getters_setters-expected.txt @@ -211,12 +211,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_class_with_getters_setters.ets" } } }, @@ -224,12 +224,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_class_with_getters_setters.ets" } } }, @@ -237,12 +237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_class_with_getters_setters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_class_with_getters_setters.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type-expected.txt b/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type-expected.txt index b13fb9afe6..fafbcca930 100644 --- a/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type_lib-expected.txt b/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type_lib-expected.txt index a6b4aa5d8a..b12761b7bd 100644 --- a/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type_lib-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/infer_imported_function_return_type_lib-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_imported_function_return_type_lib.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/export-expected.txt b/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/export-expected.txt index 937539ce2a..d7e4adcd2f 100644 --- a/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/export-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/export-expected.txt @@ -457,12 +457,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -470,12 +470,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -483,12 +483,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -626,40 +626,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 44, + "program": "export.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 44, + "program": "export.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 44, + "program": "export.ets" } } }, @@ -667,13 +667,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "export.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 44, "program": "export.ets" } } diff --git a/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/import_aliased_re-export-expected.txt b/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/import_aliased_re-export-expected.txt index 0748020cdb..06e3ee1472 100644 --- a/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/import_aliased_re-export-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/import_aliased_re-export-expected.txt @@ -293,12 +293,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_aliased_re-export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_aliased_re-export.ets" } } }, @@ -306,12 +306,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_aliased_re-export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_aliased_re-export.ets" } } }, @@ -319,12 +319,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_aliased_re-export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_aliased_re-export.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/re-export_with_alias-expected.txt b/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/re-export_with_alias-expected.txt index edfd5063db..e63e571c90 100644 --- a/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/re-export_with_alias-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/re-export_with_alias/re-export_with_alias-expected.txt @@ -323,12 +323,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" } } }, @@ -336,12 +336,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" } } }, @@ -349,12 +349,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" } } }, @@ -429,12 +429,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" } } }, @@ -442,12 +442,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" } } }, @@ -455,12 +455,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re-export_with_alias.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_interface-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_interface-expected.txt index 99b6763f23..dd90a1ec71 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_interface-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_interface-expected.txt @@ -647,12 +647,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" } } }, @@ -660,12 +660,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" } } }, @@ -673,12 +673,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" } } }, @@ -753,12 +753,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" } } }, @@ -766,12 +766,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" } } }, @@ -779,12 +779,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_selective_exported-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_selective_exported-expected.txt index 503604c72b..ce1c79c1a8 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_selective_exported-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/import_selective_exported-expected.txt @@ -227,12 +227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_selective_exported.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_selective_exported.ets" } } }, @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_selective_exported.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_selective_exported.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_selective_exported.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_selective_exported.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export-expected.txt index 8f2595b450..08cdb11de2 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export-expected.txt @@ -868,12 +868,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export.ets" } } }, @@ -881,12 +881,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export.ets" } } }, @@ -894,12 +894,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export.ets" } } }, @@ -1101,40 +1101,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "selective_export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 27, + "program": "selective_export.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "selective_export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 27, + "program": "selective_export.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "selective_export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 27, + "program": "selective_export.ets" } } }, @@ -1142,13 +1142,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "selective_export.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 27, "program": "selective_export.ets" } } diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_function-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_function-expected.txt index 191cade283..3d742e0bd5 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_function-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_function-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_function.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_interface-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_interface-expected.txt index 2793feea08..986b4a3f83 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_interface-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_interface-expected.txt @@ -178,12 +178,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" } } }, @@ -191,12 +191,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" } } }, @@ -204,12 +204,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" } } }, @@ -284,12 +284,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" } } }, @@ -297,12 +297,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" } } }, @@ -310,12 +310,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_interface.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_with_alias-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_with_alias-expected.txt index 61b96e29de..f00f4668bc 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_with_alias-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_export_with_alias-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_with_alias.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_with_alias.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_with_alias.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "selective_export_with_alias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 18, + "program": "selective_export_with_alias.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "selective_export_with_alias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 18, + "program": "selective_export_with_alias.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "selective_export_with_alias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 18, + "program": "selective_export_with_alias.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "selective_export_with_alias.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 18, "program": "selective_export_with_alias.ets" } } diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_1-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_1-expected.txt index 5b31ff5f4d..d2e7b53338 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_1-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_1-expected.txt @@ -380,12 +380,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" } } }, @@ -393,12 +393,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" } } }, @@ -406,12 +406,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" } } }, @@ -486,12 +486,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" } } }, @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" } } }, @@ -512,12 +512,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_2-expected.txt b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_2-expected.txt index 88a32d0156..be43e25602 100644 --- a/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_2-expected.txt +++ b/ets2panda/test/compiler/ets/import_tests/selective_export_tests/selective_import_with_alias_2-expected.txt @@ -380,12 +380,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" } } }, @@ -393,12 +393,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" } } }, @@ -406,12 +406,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" } } }, @@ -486,12 +486,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" } } }, @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" } } }, @@ -512,12 +512,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_import_with_alias_2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/import_type-expected.txt b/ets2panda/test/compiler/ets/import_type-expected.txt index 4624e649f5..a7d06b7c06 100644 --- a/ets2panda/test/compiler/ets/import_type-expected.txt +++ b/ets2panda/test/compiler/ets/import_type-expected.txt @@ -478,12 +478,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_type.ets" } } }, @@ -491,12 +491,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_type.ets" } } }, @@ -504,12 +504,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_type.ets" } } }, @@ -916,40 +916,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_type.ets" }, "end": { - "line": 1, + "line": 22, "column": 1, - "program": null + "program": "import_type.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_type.ets" }, "end": { - "line": 1, + "line": 22, "column": 1, - "program": null + "program": "import_type.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_type.ets" }, "end": { - "line": 1, + "line": 22, "column": 1, - "program": null + "program": "import_type.ets" } } }, @@ -957,12 +957,12 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "import_type.ets" }, "end": { - "line": 1, + "line": 22, "column": 1, "program": "import_type.ets" } diff --git a/ets2panda/test/compiler/ets/inferTypeOfArray-expected.txt b/ets2panda/test/compiler/ets/inferTypeOfArray-expected.txt index 760183394c..64c0c8c1e3 100644 --- a/ets2panda/test/compiler/ets/inferTypeOfArray-expected.txt +++ b/ets2panda/test/compiler/ets/inferTypeOfArray-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inferTypeOfArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inferTypeOfArray.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inferTypeOfArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inferTypeOfArray.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inferTypeOfArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inferTypeOfArray.ets" } } }, @@ -1088,40 +1088,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "inferTypeOfArray.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 24, + "column": 9, + "program": "inferTypeOfArray.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "inferTypeOfArray.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 24, + "column": 9, + "program": "inferTypeOfArray.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "inferTypeOfArray.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 24, + "column": 9, + "program": "inferTypeOfArray.ets" } } }, @@ -1129,13 +1129,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "inferTypeOfArray.ets" }, "end": { - "line": 1, - "column": 1, + "line": 24, + "column": 9, "program": "inferTypeOfArray.ets" } } diff --git a/ets2panda/test/compiler/ets/instanceof_object_long-expected.txt b/ets2panda/test/compiler/ets/instanceof_object_long-expected.txt index 44c942b99d..a93110f754 100644 --- a/ets2panda/test/compiler/ets/instanceof_object_long-expected.txt +++ b/ets2panda/test/compiler/ets/instanceof_object_long-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof_object_long.ets" } } }, diff --git a/ets2panda/test/compiler/ets/interface_noreturn_type_function-expected.txt b/ets2panda/test/compiler/ets/interface_noreturn_type_function-expected.txt index 1bc910d1e7..b1e5388cad 100644 --- a/ets2panda/test/compiler/ets/interface_noreturn_type_function-expected.txt +++ b/ets2panda/test/compiler/ets/interface_noreturn_type_function-expected.txt @@ -486,12 +486,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_noreturn_type_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_noreturn_type_function.ets" } } }, @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_noreturn_type_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_noreturn_type_function.ets" } } }, @@ -512,12 +512,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_noreturn_type_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_noreturn_type_function.ets" } } }, diff --git a/ets2panda/test/compiler/ets/invalidCallInstruction-expected.txt b/ets2panda/test/compiler/ets/invalidCallInstruction-expected.txt index 618c51090b..c182fe1332 100644 --- a/ets2panda/test/compiler/ets/invalidCallInstruction-expected.txt +++ b/ets2panda/test/compiler/ets/invalidCallInstruction-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidCallInstruction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidCallInstruction.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidCallInstruction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidCallInstruction.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidCallInstruction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidCallInstruction.ets" } } }, diff --git a/ets2panda/test/compiler/ets/invalidInheritance3-expected.txt b/ets2panda/test/compiler/ets/invalidInheritance3-expected.txt index 89d140de9f..3e6c99e7be 100644 --- a/ets2panda/test/compiler/ets/invalidInheritance3-expected.txt +++ b/ets2panda/test/compiler/ets/invalidInheritance3-expected.txt @@ -836,12 +836,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" } } }, @@ -849,12 +849,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" } } }, @@ -862,12 +862,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" } } }, @@ -942,12 +942,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" } } }, @@ -955,12 +955,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" } } }, @@ -968,12 +968,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "invalidInheritance3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambdaFunction1-expected.txt b/ets2panda/test/compiler/ets/lambdaFunction1-expected.txt index 79e03cb456..327c2296c5 100644 --- a/ets2panda/test/compiler/ets/lambdaFunction1-expected.txt +++ b/ets2panda/test/compiler/ets/lambdaFunction1-expected.txt @@ -1108,40 +1108,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambdaFunction1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 2, + "program": "lambdaFunction1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambdaFunction1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 2, + "program": "lambdaFunction1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambdaFunction1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 2, + "program": "lambdaFunction1.ets" } } }, @@ -1149,13 +1149,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "lambdaFunction1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 2, "program": "lambdaFunction1.ets" } } diff --git a/ets2panda/test/compiler/ets/lambdaFunctionArrayDeclaration-expected.txt b/ets2panda/test/compiler/ets/lambdaFunctionArrayDeclaration-expected.txt index 8653854d80..d8d092b9db 100644 --- a/ets2panda/test/compiler/ets/lambdaFunctionArrayDeclaration-expected.txt +++ b/ets2panda/test/compiler/ets/lambdaFunctionArrayDeclaration-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaFunctionArrayDeclaration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaFunctionArrayDeclaration.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaFunctionArrayDeclaration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaFunctionArrayDeclaration.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaFunctionArrayDeclaration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaFunctionArrayDeclaration.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_capturing-expected.txt b/ets2panda/test/compiler/ets/lambda_capturing-expected.txt index 95324f7bff..47376b0f3a 100644 --- a/ets2panda/test/compiler/ets/lambda_capturing-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_capturing-expected.txt @@ -191,12 +191,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" } } }, @@ -204,12 +204,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" } } }, @@ -217,12 +217,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" } } }, @@ -297,12 +297,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" } } }, @@ -310,12 +310,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" } } }, @@ -323,12 +323,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_capturing.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_narrowing-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_narrowing-expected.txt index c7634b64c2..7ee5a14864 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_narrowing-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_narrowing-expected.txt @@ -1171,12 +1171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" } } }, @@ -1184,12 +1184,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" } } }, @@ -1197,12 +1197,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" } } }, @@ -1277,12 +1277,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" } } }, @@ -1290,12 +1290,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" } } }, @@ -1303,12 +1303,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_narrowing.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_void-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_void-expected.txt index e0b68b4ea0..a8931f6bfd 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_void-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_void-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_void.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_void.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_void.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_widening-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_widening-expected.txt index 9d0c4a664c..39f4aa30bb 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_widening-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_infer_type_widening-expected.txt @@ -1171,12 +1171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" } } }, @@ -1184,12 +1184,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" } } }, @@ -1197,12 +1197,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" } } }, @@ -1277,12 +1277,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" } } }, @@ -1290,12 +1290,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" } } }, @@ -1303,12 +1303,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_infer_type_widening.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_type_has_pramas-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_type_has_pramas-expected.txt index 52981c41e9..2785b4bdfc 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_type_has_pramas-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_cast_type_has_pramas-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_type_has_pramas.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_type_has_pramas.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_type_has_pramas.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_type_has_pramas.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_type_has_pramas.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_cast_type_has_pramas.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type-expected.txt index 50a8f9b7df..fc933990d6 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression-expected.txt index d76dc0af96..94ab0e2a26 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression-expected.txt @@ -652,12 +652,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" } } }, @@ -665,12 +665,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" } } }, @@ -678,12 +678,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" } } }, @@ -758,12 +758,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" } } }, @@ -771,12 +771,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression_literal-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression_literal-expected.txt index acb76e09d4..84d41df13b 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression_literal-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_arrow_expression_literal-expected.txt @@ -605,12 +605,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" } } }, @@ -618,12 +618,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" } } }, @@ -631,12 +631,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" } } }, @@ -711,12 +711,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" } } }, @@ -724,12 +724,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" } } }, @@ -737,12 +737,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_arrow_expression_literal.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_has_return-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_has_return-expected.txt index 27526a0561..84661a9951 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_has_return-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_has_return-expected.txt @@ -766,12 +766,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" } } }, @@ -779,12 +779,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" } } }, @@ -792,12 +792,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" } } }, @@ -872,12 +872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" } } }, @@ -885,12 +885,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" } } }, @@ -898,12 +898,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_has_return.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_param2-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_param2-expected.txt index 39e640a0ff..c51dad8af4 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_param2-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_param2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_param2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_param2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_param2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_param2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_param2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_param2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_array-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_array-expected.txt index 436191e910..46493e52c9 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_array-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_array-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_array.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_array.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_array.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda-expected.txt index 0e150addfb..1b6f4822a1 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda1-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda1-expected.txt index 026159d3ce..74a58d79df 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda1-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda_expression-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda_expression-expected.txt index 54f0403fca..6aab64e572 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda_expression-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_lambda_expression-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda_expression.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda_expression.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_lambda_expression.ets" } } }, @@ -267,40 +267,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 5, + "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 43, + "program": "lambda_infer_type_return_lambda_expression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 5, + "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 43, + "program": "lambda_infer_type_return_lambda_expression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 5, + "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 43, + "program": "lambda_infer_type_return_lambda_expression.ets" } } }, @@ -308,13 +308,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 23, + "column": 5, "program": "lambda_infer_type_return_lambda_expression.ets" }, "end": { - "line": 1, - "column": 1, + "line": 23, + "column": 43, "program": "lambda_infer_type_return_lambda_expression.ets" } } diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_literal-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_literal-expected.txt index 573e531158..e52b2b93df 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_literal-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_literal-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_literal.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_literal.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_literal.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_union-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_union-expected.txt index 389e4d15b3..15901d7ccc 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_union-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_return_union-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_union.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_union.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_union.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_union.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_union.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_infer_type_return_union.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_scope-expected.txt b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_scope-expected.txt index 90bba90003..37cc75cacd 100644 --- a/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_scope-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_infer_type/lambda_infer_type_scope-expected.txt @@ -356,40 +356,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambda_infer_type_scope.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 29, + "program": "lambda_infer_type_scope.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambda_infer_type_scope.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 29, + "program": "lambda_infer_type_scope.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambda_infer_type_scope.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 29, + "program": "lambda_infer_type_scope.ets" } } }, @@ -397,13 +397,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "lambda_infer_type_scope.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 29, "program": "lambda_infer_type_scope.ets" } } diff --git a/ets2panda/test/compiler/ets/lambda_unresolved_ref_1-expected.txt b/ets2panda/test/compiler/ets/lambda_unresolved_ref_1-expected.txt index 798ebcd037..384e306625 100644 --- a/ets2panda/test/compiler/ets/lambda_unresolved_ref_1-expected.txt +++ b/ets2panda/test/compiler/ets/lambda_unresolved_ref_1-expected.txt @@ -798,12 +798,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_unresolved_ref_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_unresolved_ref_1.ets" } } }, @@ -811,12 +811,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_unresolved_ref_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_unresolved_ref_1.ets" } } }, @@ -824,12 +824,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_unresolved_ref_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_unresolved_ref_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/launch_expression-expected.txt b/ets2panda/test/compiler/ets/launch_expression-expected.txt index fd80bda179..10c0205c50 100644 --- a/ets2panda/test/compiler/ets/launch_expression-expected.txt +++ b/ets2panda/test/compiler/ets/launch_expression-expected.txt @@ -654,40 +654,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "launch_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 30, + "program": "launch_expression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "launch_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 30, + "program": "launch_expression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "launch_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 30, + "program": "launch_expression.ets" } } }, @@ -695,13 +695,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "launch_expression.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 30, "program": "launch_expression.ets" } } diff --git a/ets2panda/test/compiler/ets/loopWithinLambda-expected.txt b/ets2panda/test/compiler/ets/loopWithinLambda-expected.txt index 2dffdc1e5b..a281d834d8 100644 --- a/ets2panda/test/compiler/ets/loopWithinLambda-expected.txt +++ b/ets2panda/test/compiler/ets/loopWithinLambda-expected.txt @@ -524,12 +524,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "loopWithinLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "loopWithinLambda.ets" } } }, @@ -537,12 +537,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "loopWithinLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "loopWithinLambda.ets" } } }, @@ -550,12 +550,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "loopWithinLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "loopWithinLambda.ets" } } }, diff --git a/ets2panda/test/compiler/ets/lowering-interaction-expected.txt b/ets2panda/test/compiler/ets/lowering-interaction-expected.txt index 1da047d076..e97d598b79 100644 --- a/ets2panda/test/compiler/ets/lowering-interaction-expected.txt +++ b/ets2panda/test/compiler/ets/lowering-interaction-expected.txt @@ -1529,12 +1529,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" } } }, @@ -1542,12 +1542,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" } } }, @@ -1555,12 +1555,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" } } }, @@ -1635,12 +1635,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" } } }, @@ -1648,12 +1648,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" } } }, @@ -1661,12 +1661,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lowering-interaction.ets" } } }, diff --git a/ets2panda/test/compiler/ets/manyLocalsParamRegUsage-expected.txt b/ets2panda/test/compiler/ets/manyLocalsParamRegUsage-expected.txt index 368b383ee1..c1180a7184 100644 --- a/ets2panda/test/compiler/ets/manyLocalsParamRegUsage-expected.txt +++ b/ets2panda/test/compiler/ets/manyLocalsParamRegUsage-expected.txt @@ -35382,12 +35382,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" } } }, @@ -35395,12 +35395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" } } }, @@ -35408,12 +35408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" } } }, @@ -35488,12 +35488,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" } } }, @@ -35501,12 +35501,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" } } }, @@ -35514,12 +35514,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "manyLocalsParamRegUsage.ets" } } }, diff --git a/ets2panda/test/compiler/ets/memberExprInLambda-expected.txt b/ets2panda/test/compiler/ets/memberExprInLambda-expected.txt index 1e77ccc4d0..4d8fc13a42 100644 --- a/ets2panda/test/compiler/ets/memberExprInLambda-expected.txt +++ b/ets2panda/test/compiler/ets/memberExprInLambda-expected.txt @@ -143,12 +143,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" } } }, @@ -156,12 +156,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" } } }, @@ -169,12 +169,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" } } }, @@ -249,12 +249,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" } } }, @@ -262,12 +262,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" } } }, @@ -275,12 +275,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExprInLambda.ets" } } }, diff --git a/ets2panda/test/compiler/ets/memberExpressionFromStaticContext-expected.txt b/ets2panda/test/compiler/ets/memberExpressionFromStaticContext-expected.txt index 77e24d2125..aa4becc750 100644 --- a/ets2panda/test/compiler/ets/memberExpressionFromStaticContext-expected.txt +++ b/ets2panda/test/compiler/ets/memberExpressionFromStaticContext-expected.txt @@ -3062,12 +3062,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" } } }, @@ -3075,12 +3075,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" } } }, @@ -3088,12 +3088,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" } } }, @@ -3168,12 +3168,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" } } }, @@ -3181,12 +3181,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" } } }, @@ -3194,12 +3194,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "memberExpressionFromStaticContext.ets" } } }, diff --git a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt index 31d7c0bbe3..b70b285df1 100644 --- a/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt +++ b/ets2panda/test/compiler/ets/method-resolution-class-and-interface-in-signatures_5-expected.txt @@ -860,12 +860,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method-resolution-class-and-interface-in-signatures_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method-resolution-class-and-interface-in-signatures_5.ets" } } }, @@ -873,12 +873,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method-resolution-class-and-interface-in-signatures_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method-resolution-class-and-interface-in-signatures_5.ets" } } }, @@ -886,12 +886,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method-resolution-class-and-interface-in-signatures_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method-resolution-class-and-interface-in-signatures_5.ets" } } }, diff --git a/ets2panda/test/compiler/ets/methodOverrideAsyncMethod-expected.txt b/ets2panda/test/compiler/ets/methodOverrideAsyncMethod-expected.txt index a3889c32e1..206c21a661 100644 --- a/ets2panda/test/compiler/ets/methodOverrideAsyncMethod-expected.txt +++ b/ets2panda/test/compiler/ets/methodOverrideAsyncMethod-expected.txt @@ -1307,12 +1307,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" } } }, @@ -1320,12 +1320,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" } } }, @@ -1333,12 +1333,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" } } }, @@ -1413,12 +1413,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" } } }, @@ -1426,12 +1426,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" } } }, @@ -1439,12 +1439,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideAsyncMethod.ets" } } }, diff --git a/ets2panda/test/compiler/ets/methodOverrideCovariantReturnType-expected.txt b/ets2panda/test/compiler/ets/methodOverrideCovariantReturnType-expected.txt index cd642fce8c..8c6d7bdc2d 100644 --- a/ets2panda/test/compiler/ets/methodOverrideCovariantReturnType-expected.txt +++ b/ets2panda/test/compiler/ets/methodOverrideCovariantReturnType-expected.txt @@ -2210,12 +2210,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" } } }, @@ -2223,12 +2223,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" } } }, @@ -2236,12 +2236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" } } }, @@ -2316,12 +2316,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" } } }, @@ -2329,12 +2329,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" } } }, @@ -2342,12 +2342,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideCovariantReturnType.ets" } } }, diff --git a/ets2panda/test/compiler/ets/methodOverrideDifferentSignature-expected.txt b/ets2panda/test/compiler/ets/methodOverrideDifferentSignature-expected.txt index 2f6c7b678c..073ac383ab 100644 --- a/ets2panda/test/compiler/ets/methodOverrideDifferentSignature-expected.txt +++ b/ets2panda/test/compiler/ets/methodOverrideDifferentSignature-expected.txt @@ -1494,12 +1494,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" } } }, @@ -1507,12 +1507,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" } } }, @@ -1520,12 +1520,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" } } }, @@ -1600,12 +1600,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" } } }, @@ -1613,12 +1613,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" } } }, @@ -1626,12 +1626,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideDifferentSignature.ets" } } }, diff --git a/ets2panda/test/compiler/ets/methodOverrideWithoutModifier-expected.txt b/ets2panda/test/compiler/ets/methodOverrideWithoutModifier-expected.txt index 864cd808e4..b0e01bfbf1 100644 --- a/ets2panda/test/compiler/ets/methodOverrideWithoutModifier-expected.txt +++ b/ets2panda/test/compiler/ets/methodOverrideWithoutModifier-expected.txt @@ -678,12 +678,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" } } }, @@ -691,12 +691,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" } } }, @@ -704,12 +704,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" } } }, @@ -797,12 +797,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" } } }, @@ -810,12 +810,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodOverrideWithoutModifier.ets" } } }, diff --git a/ets2panda/test/compiler/ets/multipleMethodOverride-expected.txt b/ets2panda/test/compiler/ets/multipleMethodOverride-expected.txt index 1a388bd32d..89d9bd1226 100644 --- a/ets2panda/test/compiler/ets/multipleMethodOverride-expected.txt +++ b/ets2panda/test/compiler/ets/multipleMethodOverride-expected.txt @@ -1201,12 +1201,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" } } }, @@ -1214,12 +1214,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" } } }, @@ -1227,12 +1227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" } } }, @@ -1307,12 +1307,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" } } }, @@ -1320,12 +1320,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" } } }, @@ -1333,12 +1333,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "multipleMethodOverride.ets" } } }, diff --git a/ets2panda/test/compiler/ets/n_nullableTypeInArgNotRef-expected.txt b/ets2panda/test/compiler/ets/n_nullableTypeInArgNotRef-expected.txt index 022f65668f..54d1502833 100644 --- a/ets2panda/test/compiler/ets/n_nullableTypeInArgNotRef-expected.txt +++ b/ets2panda/test/compiler/ets/n_nullableTypeInArgNotRef-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInArgNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInArgNotRef.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInArgNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInArgNotRef.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInArgNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInArgNotRef.ets" } } }, diff --git a/ets2panda/test/compiler/ets/n_nullableTypeInReturnNotRef-expected.txt b/ets2panda/test/compiler/ets/n_nullableTypeInReturnNotRef-expected.txt index 447ba60159..0dfca43de8 100644 --- a/ets2panda/test/compiler/ets/n_nullableTypeInReturnNotRef-expected.txt +++ b/ets2panda/test/compiler/ets/n_nullableTypeInReturnNotRef-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInReturnNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInReturnNotRef.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInReturnNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInReturnNotRef.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInReturnNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeInReturnNotRef.ets" } } }, diff --git a/ets2panda/test/compiler/ets/n_nullableTypeNotRef-expected.txt b/ets2panda/test/compiler/ets/n_nullableTypeNotRef-expected.txt index 34b399bb68..dc47fc9969 100644 --- a/ets2panda/test/compiler/ets/n_nullableTypeNotRef-expected.txt +++ b/ets2panda/test/compiler/ets/n_nullableTypeNotRef-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeNotRef.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeNotRef.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeNotRef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "n_nullableTypeNotRef.ets" } } }, diff --git a/ets2panda/test/compiler/ets/native_toplevel-expected.txt b/ets2panda/test/compiler/ets/native_toplevel-expected.txt index 88d918fd56..58147c8f0a 100644 --- a/ets2panda/test/compiler/ets/native_toplevel-expected.txt +++ b/ets2panda/test/compiler/ets/native_toplevel-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_toplevel.ets" } } }, diff --git a/ets2panda/test/compiler/ets/non-const-lambda-with-scopes-expected.txt b/ets2panda/test/compiler/ets/non-const-lambda-with-scopes-expected.txt index 6c210630f9..640f23ecb7 100644 --- a/ets2panda/test/compiler/ets/non-const-lambda-with-scopes-expected.txt +++ b/ets2panda/test/compiler/ets/non-const-lambda-with-scopes-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "non-const-lambda-with-scopes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "non-const-lambda-with-scopes.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "non-const-lambda-with-scopes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "non-const-lambda-with-scopes.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "non-const-lambda-with-scopes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "non-const-lambda-with-scopes.ets" } } }, diff --git a/ets2panda/test/compiler/ets/null_coalescing_generic_1-expected.txt b/ets2panda/test/compiler/ets/null_coalescing_generic_1-expected.txt index e129c87f44..c03de913a8 100644 --- a/ets2panda/test/compiler/ets/null_coalescing_generic_1-expected.txt +++ b/ets2panda/test/compiler/ets/null_coalescing_generic_1-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_coalescing_generic_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/nullableTuple-expected.txt b/ets2panda/test/compiler/ets/nullableTuple-expected.txt index 9e7a3740c3..b8e7ca99db 100644 --- a/ets2panda/test/compiler/ets/nullableTuple-expected.txt +++ b/ets2panda/test/compiler/ets/nullableTuple-expected.txt @@ -334,12 +334,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableTuple.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableTuple.ets" } } }, @@ -347,12 +347,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableTuple.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableTuple.ets" } } }, @@ -360,12 +360,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableTuple.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableTuple.ets" } } }, diff --git a/ets2panda/test/compiler/ets/nullable_type_in_arithmeticdiv-expected.txt b/ets2panda/test/compiler/ets/nullable_type_in_arithmeticdiv-expected.txt index 15d582ab65..8ba128c655 100644 --- a/ets2panda/test/compiler/ets/nullable_type_in_arithmeticdiv-expected.txt +++ b/ets2panda/test/compiler/ets/nullable_type_in_arithmeticdiv-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticdiv.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticdiv.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticdiv.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticdiv.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticdiv.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticdiv.ets" } } }, diff --git a/ets2panda/test/compiler/ets/nullable_type_in_arithmeticplus-expected.txt b/ets2panda/test/compiler/ets/nullable_type_in_arithmeticplus-expected.txt index 8ea7dac534..44d8c319bc 100644 --- a/ets2panda/test/compiler/ets/nullable_type_in_arithmeticplus-expected.txt +++ b/ets2panda/test/compiler/ets/nullable_type_in_arithmeticplus-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticplus.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticplus.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticplus.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticplus.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticplus.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_type_in_arithmeticplus.ets" } } }, diff --git a/ets2panda/test/compiler/ets/objectLiteralInterface-expected.txt b/ets2panda/test/compiler/ets/objectLiteralInterface-expected.txt index b801c25676..f8825ab52e 100644 --- a/ets2panda/test/compiler/ets/objectLiteralInterface-expected.txt +++ b/ets2panda/test/compiler/ets/objectLiteralInterface-expected.txt @@ -129,12 +129,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralInterface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralInterface.ets" } } }, @@ -142,12 +142,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralInterface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralInterface.ets" } } }, @@ -155,12 +155,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralInterface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralInterface.ets" } } }, @@ -298,40 +298,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "objectLiteralInterface.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 14, + "program": "objectLiteralInterface.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "objectLiteralInterface.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 14, + "program": "objectLiteralInterface.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "objectLiteralInterface.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 14, + "program": "objectLiteralInterface.ets" } } }, @@ -339,13 +339,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "objectLiteralInterface.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 14, "program": "objectLiteralInterface.ets" } } diff --git a/ets2panda/test/compiler/ets/objectLiteralReadonlyKey-expected.txt b/ets2panda/test/compiler/ets/objectLiteralReadonlyKey-expected.txt index 21e8d6b6f5..c6b01e8dda 100644 --- a/ets2panda/test/compiler/ets/objectLiteralReadonlyKey-expected.txt +++ b/ets2panda/test/compiler/ets/objectLiteralReadonlyKey-expected.txt @@ -290,12 +290,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralReadonlyKey.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralReadonlyKey.ets" } } }, @@ -303,12 +303,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralReadonlyKey.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralReadonlyKey.ets" } } }, @@ -316,12 +316,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralReadonlyKey.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "objectLiteralReadonlyKey.ets" } } }, @@ -512,40 +512,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "objectLiteralReadonlyKey.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 2, + "program": "objectLiteralReadonlyKey.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "objectLiteralReadonlyKey.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 2, + "program": "objectLiteralReadonlyKey.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "objectLiteralReadonlyKey.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 2, + "program": "objectLiteralReadonlyKey.ets" } } }, @@ -553,13 +553,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 20, + "column": 5, "program": "objectLiteralReadonlyKey.ets" }, "end": { - "line": 1, - "column": 1, + "line": 22, + "column": 2, "program": "objectLiteralReadonlyKey.ets" } } diff --git a/ets2panda/test/compiler/ets/overload_with_generics-expected.txt b/ets2panda/test/compiler/ets/overload_with_generics-expected.txt index f5ca8d7c55..d7052bb048 100644 --- a/ets2panda/test/compiler/ets/overload_with_generics-expected.txt +++ b/ets2panda/test/compiler/ets/overload_with_generics-expected.txt @@ -847,12 +847,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overload_with_generics.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overload_with_generics.ets" } } }, @@ -860,12 +860,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overload_with_generics.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overload_with_generics.ets" } } }, @@ -873,12 +873,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overload_with_generics.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overload_with_generics.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override-expected.txt b/ets2panda/test/compiler/ets/override-expected.txt index f8a1434f18..19c3e87f37 100644 --- a/ets2panda/test/compiler/ets/override-expected.txt +++ b/ets2panda/test/compiler/ets/override-expected.txt @@ -1958,12 +1958,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override.ets" } } }, @@ -1971,12 +1971,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override.ets" } } }, @@ -1984,12 +1984,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override10-expected.txt b/ets2panda/test/compiler/ets/override10-expected.txt index 538955d3af..9d7a82d6d2 100644 --- a/ets2panda/test/compiler/ets/override10-expected.txt +++ b/ets2panda/test/compiler/ets/override10-expected.txt @@ -953,12 +953,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" } } }, @@ -966,12 +966,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" } } }, @@ -979,12 +979,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" } } }, @@ -1059,12 +1059,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" } } }, @@ -1072,12 +1072,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" } } }, @@ -1085,12 +1085,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override10.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override12-expected.txt b/ets2panda/test/compiler/ets/override12-expected.txt index b36a9566bd..35d00ec6c9 100644 --- a/ets2panda/test/compiler/ets/override12-expected.txt +++ b/ets2panda/test/compiler/ets/override12-expected.txt @@ -1664,12 +1664,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" } } }, @@ -1677,12 +1677,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" } } }, @@ -1690,12 +1690,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" } } }, @@ -1770,12 +1770,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" } } }, @@ -1783,12 +1783,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" } } }, @@ -1796,12 +1796,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override12.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override13-expected.txt b/ets2panda/test/compiler/ets/override13-expected.txt index 5b4c925f6b..f38d28582b 100644 --- a/ets2panda/test/compiler/ets/override13-expected.txt +++ b/ets2panda/test/compiler/ets/override13-expected.txt @@ -1066,12 +1066,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" } } }, @@ -1079,12 +1079,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" } } }, @@ -1092,12 +1092,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" } } }, @@ -1172,12 +1172,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" } } }, @@ -1185,12 +1185,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" } } }, @@ -1198,12 +1198,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override13.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override16-expected.txt b/ets2panda/test/compiler/ets/override16-expected.txt index 3032322afa..cb2c09ed0f 100644 --- a/ets2panda/test/compiler/ets/override16-expected.txt +++ b/ets2panda/test/compiler/ets/override16-expected.txt @@ -811,12 +811,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" } } }, @@ -824,12 +824,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" } } }, @@ -837,12 +837,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" } } }, @@ -917,12 +917,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" } } }, @@ -930,12 +930,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" } } }, @@ -943,12 +943,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override16.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override17-expected.txt b/ets2panda/test/compiler/ets/override17-expected.txt index bdf99d6d06..004feec041 100644 --- a/ets2panda/test/compiler/ets/override17-expected.txt +++ b/ets2panda/test/compiler/ets/override17-expected.txt @@ -811,12 +811,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" } } }, @@ -824,12 +824,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" } } }, @@ -837,12 +837,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" } } }, @@ -917,12 +917,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" } } }, @@ -930,12 +930,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" } } }, @@ -943,12 +943,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override17.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override19-expected.txt b/ets2panda/test/compiler/ets/override19-expected.txt index b59347f3ff..41840f86e8 100644 --- a/ets2panda/test/compiler/ets/override19-expected.txt +++ b/ets2panda/test/compiler/ets/override19-expected.txt @@ -774,12 +774,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override19.ets" } } }, @@ -787,12 +787,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override19.ets" } } }, @@ -800,12 +800,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override19.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override2-expected.txt b/ets2panda/test/compiler/ets/override2-expected.txt index d38e7aa40f..53be47c079 100644 --- a/ets2panda/test/compiler/ets/override2-expected.txt +++ b/ets2panda/test/compiler/ets/override2-expected.txt @@ -807,12 +807,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" } } }, @@ -820,12 +820,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" } } }, @@ -833,12 +833,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" } } }, @@ -913,12 +913,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" } } }, @@ -926,12 +926,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" } } }, @@ -939,12 +939,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override4-expected.txt b/ets2panda/test/compiler/ets/override4-expected.txt index 2948b976cb..0c3b9d47a5 100644 --- a/ets2panda/test/compiler/ets/override4-expected.txt +++ b/ets2panda/test/compiler/ets/override4-expected.txt @@ -855,12 +855,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" } } }, @@ -868,12 +868,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" } } }, @@ -881,12 +881,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" } } }, @@ -961,12 +961,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" } } }, @@ -974,12 +974,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" } } }, @@ -987,12 +987,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override4.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override5-expected.txt b/ets2panda/test/compiler/ets/override5-expected.txt index 35b7a674de..144d24fdb4 100644 --- a/ets2panda/test/compiler/ets/override5-expected.txt +++ b/ets2panda/test/compiler/ets/override5-expected.txt @@ -742,12 +742,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" } } }, @@ -755,12 +755,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" } } }, @@ -768,12 +768,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" } } }, @@ -848,12 +848,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" } } }, @@ -861,12 +861,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" } } }, @@ -874,12 +874,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override5.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override6-expected.txt b/ets2panda/test/compiler/ets/override6-expected.txt index 030401332d..490f67403a 100644 --- a/ets2panda/test/compiler/ets/override6-expected.txt +++ b/ets2panda/test/compiler/ets/override6-expected.txt @@ -718,12 +718,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" } } }, @@ -731,12 +731,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" } } }, @@ -744,12 +744,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" } } }, @@ -824,12 +824,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" } } }, @@ -837,12 +837,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" } } }, @@ -850,12 +850,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override6.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override8-expected.txt b/ets2panda/test/compiler/ets/override8-expected.txt index 81577b0a0a..75bd9b53c0 100644 --- a/ets2panda/test/compiler/ets/override8-expected.txt +++ b/ets2panda/test/compiler/ets/override8-expected.txt @@ -669,12 +669,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" } } }, @@ -682,12 +682,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" } } }, @@ -695,12 +695,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" } } }, @@ -775,12 +775,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" } } }, @@ -788,12 +788,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" } } }, @@ -801,12 +801,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override8.ets" } } }, diff --git a/ets2panda/test/compiler/ets/override9-expected.txt b/ets2panda/test/compiler/ets/override9-expected.txt index 006de229cb..38db0b8624 100644 --- a/ets2panda/test/compiler/ets/override9-expected.txt +++ b/ets2panda/test/compiler/ets/override9-expected.txt @@ -781,12 +781,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" } } }, @@ -794,12 +794,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" } } }, @@ -807,12 +807,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" } } }, @@ -887,12 +887,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" } } }, @@ -900,12 +900,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" } } }, @@ -913,12 +913,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override9.ets" } } }, diff --git a/ets2panda/test/compiler/ets/parenthesizedType-expected.txt b/ets2panda/test/compiler/ets/parenthesizedType-expected.txt index e28bad53eb..f51678869e 100644 --- a/ets2panda/test/compiler/ets/parenthesizedType-expected.txt +++ b/ets2panda/test/compiler/ets/parenthesizedType-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "parenthesizedType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "parenthesizedType.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "parenthesizedType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "parenthesizedType.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "parenthesizedType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "parenthesizedType.ets" } } }, diff --git a/ets2panda/test/compiler/ets/requiredType_1-expected.txt b/ets2panda/test/compiler/ets/requiredType_1-expected.txt index 02e43c739e..2059ce2410 100644 --- a/ets2panda/test/compiler/ets/requiredType_1-expected.txt +++ b/ets2panda/test/compiler/ets/requiredType_1-expected.txt @@ -370,12 +370,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_1.ets" } } }, @@ -383,12 +383,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_1.ets" } } }, @@ -396,12 +396,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/requiredType_11-expected.txt b/ets2panda/test/compiler/ets/requiredType_11-expected.txt index 90d3b08f06..41e27345ba 100644 --- a/ets2panda/test/compiler/ets/requiredType_11-expected.txt +++ b/ets2panda/test/compiler/ets/requiredType_11-expected.txt @@ -709,12 +709,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_11.ets" } } }, @@ -722,12 +722,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_11.ets" } } }, @@ -735,12 +735,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_11.ets" } } }, diff --git a/ets2panda/test/compiler/ets/requiredType_4-expected.txt b/ets2panda/test/compiler/ets/requiredType_4-expected.txt index a6e74b9ae0..4c9bbeee77 100644 --- a/ets2panda/test/compiler/ets/requiredType_4-expected.txt +++ b/ets2panda/test/compiler/ets/requiredType_4-expected.txt @@ -370,12 +370,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_4.ets" } } }, @@ -383,12 +383,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_4.ets" } } }, @@ -396,12 +396,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_4.ets" } } }, diff --git a/ets2panda/test/compiler/ets/requiredType_5-expected.txt b/ets2panda/test/compiler/ets/requiredType_5-expected.txt index 95c93ffdd8..82b78550bb 100644 --- a/ets2panda/test/compiler/ets/requiredType_5-expected.txt +++ b/ets2panda/test/compiler/ets/requiredType_5-expected.txt @@ -520,12 +520,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_5.ets" } } }, @@ -533,12 +533,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_5.ets" } } }, @@ -546,12 +546,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_5.ets" } } }, diff --git a/ets2panda/test/compiler/ets/requiredType_9-expected.txt b/ets2panda/test/compiler/ets/requiredType_9-expected.txt index 578e4d7ad2..2b7ed4053e 100644 --- a/ets2panda/test/compiler/ets/requiredType_9-expected.txt +++ b/ets2panda/test/compiler/ets/requiredType_9-expected.txt @@ -979,12 +979,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_9.ets" } } }, @@ -992,12 +992,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_9.ets" } } }, @@ -1005,12 +1005,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "requiredType_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "requiredType_9.ets" } } }, diff --git a/ets2panda/test/compiler/ets/rethrowingCheck1-expected.txt b/ets2panda/test/compiler/ets/rethrowingCheck1-expected.txt index c971b8965f..0bec23824c 100644 --- a/ets2panda/test/compiler/ets/rethrowingCheck1-expected.txt +++ b/ets2panda/test/compiler/ets/rethrowingCheck1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/rethrowingCheck4-expected.txt b/ets2panda/test/compiler/ets/rethrowingCheck4-expected.txt index ffd83cec5b..3e40070d3f 100644 --- a/ets2panda/test/compiler/ets/rethrowingCheck4-expected.txt +++ b/ets2panda/test/compiler/ets/rethrowingCheck4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingCheck4.ets" } } }, diff --git a/ets2panda/test/compiler/ets/rethrowingConstructorCheck3-expected.txt b/ets2panda/test/compiler/ets/rethrowingConstructorCheck3-expected.txt index 1a0939cc0c..0f3228d308 100644 --- a/ets2panda/test/compiler/ets/rethrowingConstructorCheck3-expected.txt +++ b/ets2panda/test/compiler/ets/rethrowingConstructorCheck3-expected.txt @@ -302,12 +302,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingConstructorCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingConstructorCheck3.ets" } } }, @@ -315,12 +315,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingConstructorCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingConstructorCheck3.ets" } } }, @@ -328,12 +328,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingConstructorCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingConstructorCheck3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/rethrowingFunctionCheck3-expected.txt b/ets2panda/test/compiler/ets/rethrowingFunctionCheck3-expected.txt index 811fac12b9..c2ee021bda 100644 --- a/ets2panda/test/compiler/ets/rethrowingFunctionCheck3-expected.txt +++ b/ets2panda/test/compiler/ets/rethrowingFunctionCheck3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingFunctionCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingFunctionCheck3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingFunctionCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingFunctionCheck3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingFunctionCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingFunctionCheck3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/rethrowingMethodCheck3-expected.txt b/ets2panda/test/compiler/ets/rethrowingMethodCheck3-expected.txt index 270f5b7066..d5b6ad05b8 100644 --- a/ets2panda/test/compiler/ets/rethrowingMethodCheck3-expected.txt +++ b/ets2panda/test/compiler/ets/rethrowingMethodCheck3-expected.txt @@ -422,12 +422,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingMethodCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingMethodCheck3.ets" } } }, @@ -435,12 +435,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingMethodCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingMethodCheck3.ets" } } }, @@ -448,12 +448,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrowingMethodCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrowingMethodCheck3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/returnTypeGenericArray-expected.txt b/ets2panda/test/compiler/ets/returnTypeGenericArray-expected.txt index ec04fccc6c..0c97dc6d80 100644 --- a/ets2panda/test/compiler/ets/returnTypeGenericArray-expected.txt +++ b/ets2panda/test/compiler/ets/returnTypeGenericArray-expected.txt @@ -1118,12 +1118,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" } } }, @@ -1131,12 +1131,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" } } }, @@ -1144,12 +1144,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" } } }, @@ -1224,12 +1224,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" } } }, @@ -1237,12 +1237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" } } }, @@ -1250,12 +1250,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnTypeGenericArray.ets" } } }, diff --git a/ets2panda/test/compiler/ets/switchStatementBoxing-expected.txt b/ets2panda/test/compiler/ets/switchStatementBoxing-expected.txt index e621a9bb8e..93586bf6dd 100644 --- a/ets2panda/test/compiler/ets/switchStatementBoxing-expected.txt +++ b/ets2panda/test/compiler/ets/switchStatementBoxing-expected.txt @@ -666,12 +666,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" } } }, @@ -679,12 +679,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" } } }, @@ -692,12 +692,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" } } }, @@ -772,12 +772,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" } } }, @@ -785,12 +785,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" } } }, @@ -798,12 +798,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementBoxing.ets" } } }, diff --git a/ets2panda/test/compiler/ets/switchStatementCorrectConversion-expected.txt b/ets2panda/test/compiler/ets/switchStatementCorrectConversion-expected.txt index 05138eb797..af7db0e4eb 100644 --- a/ets2panda/test/compiler/ets/switchStatementCorrectConversion-expected.txt +++ b/ets2panda/test/compiler/ets/switchStatementCorrectConversion-expected.txt @@ -1043,12 +1043,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" } } }, @@ -1056,12 +1056,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" } } }, @@ -1069,12 +1069,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" } } }, @@ -1149,12 +1149,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" } } }, @@ -1162,12 +1162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" } } }, @@ -1175,12 +1175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switchStatementCorrectConversion.ets" } } }, diff --git a/ets2panda/test/compiler/ets/this_type_valid_return_type-expected.txt b/ets2panda/test/compiler/ets/this_type_valid_return_type-expected.txt index a0b005774d..692685e144 100644 --- a/ets2panda/test/compiler/ets/this_type_valid_return_type-expected.txt +++ b/ets2panda/test/compiler/ets/this_type_valid_return_type-expected.txt @@ -387,12 +387,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" } } }, @@ -400,12 +400,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" } } }, @@ -413,12 +413,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" } } }, @@ -493,12 +493,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" } } }, @@ -506,12 +506,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" } } }, @@ -519,12 +519,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_valid_return_type.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwInCatchClause3-expected.txt b/ets2panda/test/compiler/ets/throwInCatchClause3-expected.txt index ddcae8fdbf..464bf819e4 100644 --- a/ets2panda/test/compiler/ets/throwInCatchClause3-expected.txt +++ b/ets2panda/test/compiler/ets/throwInCatchClause3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInCatchClause3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwInFinallyBlock1-expected.txt b/ets2panda/test/compiler/ets/throwInFinallyBlock1-expected.txt index 4ec5b9214d..b02aacc5c6 100644 --- a/ets2panda/test/compiler/ets/throwInFinallyBlock1-expected.txt +++ b/ets2panda/test/compiler/ets/throwInFinallyBlock1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInFinallyBlock1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInFinallyBlock1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInFinallyBlock1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInFinallyBlock1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInFinallyBlock1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInFinallyBlock1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwInRethrowingFunction2-expected.txt b/ets2panda/test/compiler/ets/throwInRethrowingFunction2-expected.txt index 0206339f32..831332f4df 100644 --- a/ets2panda/test/compiler/ets/throwInRethrowingFunction2-expected.txt +++ b/ets2panda/test/compiler/ets/throwInRethrowingFunction2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInRethrowingFunction2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwInThrowingFunction-expected.txt b/ets2panda/test/compiler/ets/throwInThrowingFunction-expected.txt index a677bd13a0..1033f67140 100644 --- a/ets2panda/test/compiler/ets/throwInThrowingFunction-expected.txt +++ b/ets2panda/test/compiler/ets/throwInThrowingFunction-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInThrowingFunction.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwInTryStatement-expected.txt b/ets2panda/test/compiler/ets/throwInTryStatement-expected.txt index 5b455dceb8..fcf93a23b7 100644 --- a/ets2panda/test/compiler/ets/throwInTryStatement-expected.txt +++ b/ets2panda/test/compiler/ets/throwInTryStatement-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInTryStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInTryStatement.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInTryStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInTryStatement.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwInTryStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwInTryStatement.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwingFunctionAsParameter1-expected.txt b/ets2panda/test/compiler/ets/throwingFunctionAsParameter1-expected.txt index 1b05a374db..3197e2d47e 100644 --- a/ets2panda/test/compiler/ets/throwingFunctionAsParameter1-expected.txt +++ b/ets2panda/test/compiler/ets/throwingFunctionAsParameter1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionAsParameter1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwingFunctionCheck2-expected.txt b/ets2panda/test/compiler/ets/throwingFunctionCheck2-expected.txt index cc12ad55a9..c41bca3df3 100644 --- a/ets2panda/test/compiler/ets/throwingFunctionCheck2-expected.txt +++ b/ets2panda/test/compiler/ets/throwingFunctionCheck2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwingFunctionCheck3-expected.txt b/ets2panda/test/compiler/ets/throwingFunctionCheck3-expected.txt index d9f11899d8..379a1fef2d 100644 --- a/ets2panda/test/compiler/ets/throwingFunctionCheck3-expected.txt +++ b/ets2panda/test/compiler/ets/throwingFunctionCheck3-expected.txt @@ -358,12 +358,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck3.ets" } } }, @@ -371,12 +371,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck3.ets" } } }, @@ -384,12 +384,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwingFunctionCheck6-expected.txt b/ets2panda/test/compiler/ets/throwingFunctionCheck6-expected.txt index 767d95af48..c32efe6a7f 100644 --- a/ets2panda/test/compiler/ets/throwingFunctionCheck6-expected.txt +++ b/ets2panda/test/compiler/ets/throwingFunctionCheck6-expected.txt @@ -436,12 +436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck6.ets" } } }, @@ -449,12 +449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck6.ets" } } }, @@ -462,12 +462,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionCheck6.ets" } } }, diff --git a/ets2panda/test/compiler/ets/throwingFunctionType1-expected.txt b/ets2panda/test/compiler/ets/throwingFunctionType1-expected.txt index 123a8379e0..27e49fb626 100644 --- a/ets2panda/test/compiler/ets/throwingFunctionType1-expected.txt +++ b/ets2panda/test/compiler/ets/throwingFunctionType1-expected.txt @@ -144,12 +144,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionType1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionType1.ets" } } }, @@ -157,12 +157,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionType1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionType1.ets" } } }, @@ -170,12 +170,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionType1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwingFunctionType1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tryCatchErrorMissingParamType-expected.txt b/ets2panda/test/compiler/ets/tryCatchErrorMissingParamType-expected.txt index 7baee8c0dd..8517a871da 100644 --- a/ets2panda/test/compiler/ets/tryCatchErrorMissingParamType-expected.txt +++ b/ets2panda/test/compiler/ets/tryCatchErrorMissingParamType-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryCatchErrorMissingParamType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryCatchErrorMissingParamType.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryCatchErrorMissingParamType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryCatchErrorMissingParamType.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryCatchErrorMissingParamType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryCatchErrorMissingParamType.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tryCatchMissingParamType-expected.txt b/ets2panda/test/compiler/ets/tryCatchMissingParamType-expected.txt index 8738b66242..4b3df3d329 100644 --- a/ets2panda/test/compiler/ets/tryCatchMissingParamType-expected.txt +++ b/ets2panda/test/compiler/ets/tryCatchMissingParamType-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryCatchMissingParamType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryCatchMissingParamType.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryCatchMissingParamType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryCatchMissingParamType.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryCatchMissingParamType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryCatchMissingParamType.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tryDefaultCatches-expected.txt b/ets2panda/test/compiler/ets/tryDefaultCatches-expected.txt index 0e37bee20e..cae4964823 100644 --- a/ets2panda/test/compiler/ets/tryDefaultCatches-expected.txt +++ b/ets2panda/test/compiler/ets/tryDefaultCatches-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryDefaultCatches.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryDefaultCatches.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryDefaultCatches.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryDefaultCatches.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryDefaultCatches.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryDefaultCatches.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_1-expected.txt b/ets2panda/test/compiler/ets/tuple_types_1-expected.txt index 43b1a9cac1..f03f541e34 100644 --- a/ets2panda/test/compiler/ets/tuple_types_1-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_1-expected.txt @@ -1045,12 +1045,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_1.ets" } } }, @@ -1058,12 +1058,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_1.ets" } } }, @@ -1071,12 +1071,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_12-expected.txt b/ets2panda/test/compiler/ets/tuple_types_12-expected.txt index 10c09fb407..64c9f8e3d7 100644 --- a/ets2panda/test/compiler/ets/tuple_types_12-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_12-expected.txt @@ -759,12 +759,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_12.ets" } } }, @@ -772,12 +772,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_12.ets" } } }, @@ -785,12 +785,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_12.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_13-expected.txt b/ets2panda/test/compiler/ets/tuple_types_13-expected.txt index 014a482298..20eb7a92ff 100644 --- a/ets2panda/test/compiler/ets/tuple_types_13-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_13-expected.txt @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" } } }, @@ -376,12 +376,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" } } }, @@ -389,12 +389,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" } } }, @@ -402,12 +402,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_13.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_14-expected.txt b/ets2panda/test/compiler/ets/tuple_types_14-expected.txt index f3a64301f4..1e2a45c984 100644 --- a/ets2panda/test/compiler/ets/tuple_types_14-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_14-expected.txt @@ -790,12 +790,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_14.ets" } } }, @@ -803,12 +803,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_14.ets" } } }, @@ -816,12 +816,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_14.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_15-expected.txt b/ets2panda/test/compiler/ets/tuple_types_15-expected.txt index dfde229154..9f4319f7ac 100644 --- a/ets2panda/test/compiler/ets/tuple_types_15-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_15-expected.txt @@ -191,12 +191,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_15.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_15.ets" } } }, @@ -204,12 +204,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_15.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_15.ets" } } }, @@ -217,12 +217,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_15.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_15.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_16-expected.txt b/ets2panda/test/compiler/ets/tuple_types_16-expected.txt index 5d5e3315b1..e467d2ac93 100644 --- a/ets2panda/test/compiler/ets/tuple_types_16-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_16-expected.txt @@ -619,12 +619,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_16.ets" } } }, @@ -632,12 +632,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_16.ets" } } }, @@ -645,12 +645,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_16.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_16.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_17-expected.txt b/ets2panda/test/compiler/ets/tuple_types_17-expected.txt index ac7cf64b2e..984be6af6d 100644 --- a/ets2panda/test/compiler/ets/tuple_types_17-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_17-expected.txt @@ -255,12 +255,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_17.ets" } } }, @@ -268,12 +268,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_17.ets" } } }, @@ -281,12 +281,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_17.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_17.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_18-expected.txt b/ets2panda/test/compiler/ets/tuple_types_18-expected.txt index 7c58b43190..6c2c9e5f60 100644 --- a/ets2panda/test/compiler/ets/tuple_types_18-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_18-expected.txt @@ -302,12 +302,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_18.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_18.ets" } } }, @@ -315,12 +315,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_18.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_18.ets" } } }, @@ -328,12 +328,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_18.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_18.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_19-expected.txt b/ets2panda/test/compiler/ets/tuple_types_19-expected.txt index 17e090cb81..1dd4cab405 100644 --- a/ets2panda/test/compiler/ets/tuple_types_19-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_19-expected.txt @@ -1872,12 +1872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" } } }, @@ -1885,12 +1885,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" } } }, @@ -1898,12 +1898,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" } } }, @@ -1978,12 +1978,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" } } }, @@ -1991,12 +1991,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" } } }, @@ -2004,12 +2004,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_19.ets" } } }, diff --git a/ets2panda/test/compiler/ets/tuple_types_7-expected.txt b/ets2panda/test/compiler/ets/tuple_types_7-expected.txt index f4972d8cea..ec5cc856c2 100644 --- a/ets2panda/test/compiler/ets/tuple_types_7-expected.txt +++ b/ets2panda/test/compiler/ets/tuple_types_7-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_7.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_7.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tuple_types_7.ets" } } }, diff --git a/ets2panda/test/compiler/ets/typeAlias-expected.txt b/ets2panda/test/compiler/ets/typeAlias-expected.txt index ed6e1c5f5a..25d6a1df61 100644 --- a/ets2panda/test/compiler/ets/typeAlias-expected.txt +++ b/ets2panda/test/compiler/ets/typeAlias-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeAlias.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeAlias.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeAlias.ets" } } }, @@ -318,40 +318,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "typeAlias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 28, + "program": "typeAlias.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "typeAlias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 28, + "program": "typeAlias.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "typeAlias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 28, + "program": "typeAlias.ets" } } }, @@ -359,13 +359,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "typeAlias.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 28, "program": "typeAlias.ets" } } diff --git a/ets2panda/test/compiler/ets/typeVarReferenceFromStaticContext2-expected.txt b/ets2panda/test/compiler/ets/typeVarReferenceFromStaticContext2-expected.txt index 6c94e48e83..99dd369916 100644 --- a/ets2panda/test/compiler/ets/typeVarReferenceFromStaticContext2-expected.txt +++ b/ets2panda/test/compiler/ets/typeVarReferenceFromStaticContext2-expected.txt @@ -693,12 +693,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" } } }, @@ -706,12 +706,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" } } }, @@ -719,12 +719,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" } } }, @@ -799,12 +799,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" } } }, @@ -812,12 +812,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" } } }, @@ -825,12 +825,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "typeVarReferenceFromStaticContext2.ets" } } }, diff --git a/ets2panda/test/compiler/ets/union_types_1-expected.txt b/ets2panda/test/compiler/ets/union_types_1-expected.txt index 93b1c997cb..67fb8db8dc 100644 --- a/ets2panda/test/compiler/ets/union_types_1-expected.txt +++ b/ets2panda/test/compiler/ets/union_types_1-expected.txt @@ -1091,12 +1091,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_1.ets" } } }, @@ -1104,12 +1104,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_1.ets" } } }, @@ -1117,12 +1117,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_1.ets" } } }, diff --git a/ets2panda/test/compiler/ets/union_types_3-expected.txt b/ets2panda/test/compiler/ets/union_types_3-expected.txt index f245f08f25..a5f9e2000f 100644 --- a/ets2panda/test/compiler/ets/union_types_3-expected.txt +++ b/ets2panda/test/compiler/ets/union_types_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_3.ets" } } }, diff --git a/ets2panda/test/compiler/ets/union_types_5-expected.txt b/ets2panda/test/compiler/ets/union_types_5-expected.txt index 92a9230a27..377f67e68e 100644 --- a/ets2panda/test/compiler/ets/union_types_5-expected.txt +++ b/ets2panda/test/compiler/ets/union_types_5-expected.txt @@ -1049,12 +1049,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_5.ets" } } }, @@ -1062,12 +1062,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_5.ets" } } }, @@ -1075,12 +1075,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_5.ets" } } }, diff --git a/ets2panda/test/compiler/ets/union_types_merging-expected.txt b/ets2panda/test/compiler/ets/union_types_merging-expected.txt index 614396b8ae..54b9ed2d39 100644 --- a/ets2panda/test/compiler/ets/union_types_merging-expected.txt +++ b/ets2panda/test/compiler/ets/union_types_merging-expected.txt @@ -1998,12 +1998,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_merging.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_merging.ets" } } }, @@ -2011,12 +2011,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_merging.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_merging.ets" } } }, @@ -2024,12 +2024,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_types_merging.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_types_merging.ets" } } }, diff --git a/ets2panda/test/parser/ets/AccessBinaryTrees-expected.txt b/ets2panda/test/parser/ets/AccessBinaryTrees-expected.txt index e6a36725b3..741fd7deaa 100644 --- a/ets2panda/test/parser/ets/AccessBinaryTrees-expected.txt +++ b/ets2panda/test/parser/ets/AccessBinaryTrees-expected.txt @@ -5382,12 +5382,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessBinaryTrees.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessBinaryTrees.ets" } } }, @@ -5395,12 +5395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessBinaryTrees.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessBinaryTrees.ets" } } }, @@ -5408,12 +5408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessBinaryTrees.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessBinaryTrees.ets" } } }, diff --git a/ets2panda/test/parser/ets/AccessFannkuch-expected.txt b/ets2panda/test/parser/ets/AccessFannkuch-expected.txt index f548ec815e..65ec727abb 100644 --- a/ets2panda/test/parser/ets/AccessFannkuch-expected.txt +++ b/ets2panda/test/parser/ets/AccessFannkuch-expected.txt @@ -6199,12 +6199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessFannkuch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessFannkuch.ets" } } }, @@ -6212,12 +6212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessFannkuch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessFannkuch.ets" } } }, @@ -6225,12 +6225,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessFannkuch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessFannkuch.ets" } } }, diff --git a/ets2panda/test/parser/ets/AccessNBody-expected.txt b/ets2panda/test/parser/ets/AccessNBody-expected.txt index 3fb21b4253..c64a0444fa 100644 --- a/ets2panda/test/parser/ets/AccessNBody-expected.txt +++ b/ets2panda/test/parser/ets/AccessNBody-expected.txt @@ -16666,12 +16666,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessNBody.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessNBody.ets" } } }, @@ -16679,12 +16679,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessNBody.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessNBody.ets" } } }, @@ -16692,12 +16692,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessNBody.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessNBody.ets" } } }, diff --git a/ets2panda/test/parser/ets/AccessNSieve-expected.txt b/ets2panda/test/parser/ets/AccessNSieve-expected.txt index 29a2dc9331..55fb9c7065 100644 --- a/ets2panda/test/parser/ets/AccessNSieve-expected.txt +++ b/ets2panda/test/parser/ets/AccessNSieve-expected.txt @@ -3287,12 +3287,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessNSieve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessNSieve.ets" } } }, @@ -3300,12 +3300,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessNSieve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessNSieve.ets" } } }, @@ -3313,12 +3313,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "AccessNSieve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "AccessNSieve.ets" } } }, diff --git a/ets2panda/test/parser/ets/Bitops3BitBitsInByte-expected.txt b/ets2panda/test/parser/ets/Bitops3BitBitsInByte-expected.txt index 86dfb02a68..b1f1dd0298 100644 --- a/ets2panda/test/parser/ets/Bitops3BitBitsInByte-expected.txt +++ b/ets2panda/test/parser/ets/Bitops3BitBitsInByte-expected.txt @@ -2307,12 +2307,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Bitops3BitBitsInByte.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Bitops3BitBitsInByte.ets" } } }, @@ -2320,12 +2320,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Bitops3BitBitsInByte.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Bitops3BitBitsInByte.ets" } } }, @@ -2333,12 +2333,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Bitops3BitBitsInByte.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Bitops3BitBitsInByte.ets" } } }, diff --git a/ets2panda/test/parser/ets/BitopsBitsInByte-expected.txt b/ets2panda/test/parser/ets/BitopsBitsInByte-expected.txt index 1a0e70a27e..17e1544ecf 100644 --- a/ets2panda/test/parser/ets/BitopsBitsInByte-expected.txt +++ b/ets2panda/test/parser/ets/BitopsBitsInByte-expected.txt @@ -2049,12 +2049,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitsInByte.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitsInByte.ets" } } }, @@ -2062,12 +2062,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitsInByte.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitsInByte.ets" } } }, @@ -2075,12 +2075,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitsInByte.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitsInByte.ets" } } }, diff --git a/ets2panda/test/parser/ets/BitopsBitwiseAnd-expected.txt b/ets2panda/test/parser/ets/BitopsBitwiseAnd-expected.txt index 6a165c76e7..8d065daf16 100644 --- a/ets2panda/test/parser/ets/BitopsBitwiseAnd-expected.txt +++ b/ets2panda/test/parser/ets/BitopsBitwiseAnd-expected.txt @@ -1040,12 +1040,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitwiseAnd.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitwiseAnd.ets" } } }, @@ -1053,12 +1053,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitwiseAnd.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitwiseAnd.ets" } } }, @@ -1066,12 +1066,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitwiseAnd.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsBitwiseAnd.ets" } } }, diff --git a/ets2panda/test/parser/ets/BitopsNSieveBits-expected.txt b/ets2panda/test/parser/ets/BitopsNSieveBits-expected.txt index 6580edf138..5ca725511b 100644 --- a/ets2panda/test/parser/ets/BitopsNSieveBits-expected.txt +++ b/ets2panda/test/parser/ets/BitopsNSieveBits-expected.txt @@ -3918,12 +3918,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsNSieveBits.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsNSieveBits.ets" } } }, @@ -3931,12 +3931,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsNSieveBits.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsNSieveBits.ets" } } }, @@ -3944,12 +3944,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "BitopsNSieveBits.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "BitopsNSieveBits.ets" } } }, diff --git a/ets2panda/test/parser/ets/Boolean_bitwise-expected.txt b/ets2panda/test/parser/ets/Boolean_bitwise-expected.txt index 987ba7181c..c18cffd19e 100644 --- a/ets2panda/test/parser/ets/Boolean_bitwise-expected.txt +++ b/ets2panda/test/parser/ets/Boolean_bitwise-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Boolean_bitwise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Boolean_bitwise.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Boolean_bitwise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Boolean_bitwise.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Boolean_bitwise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Boolean_bitwise.ets" } } }, diff --git a/ets2panda/test/parser/ets/ControlFlowRecursive-expected.txt b/ets2panda/test/parser/ets/ControlFlowRecursive-expected.txt index e48834c3d5..05524201b8 100644 --- a/ets2panda/test/parser/ets/ControlFlowRecursive-expected.txt +++ b/ets2panda/test/parser/ets/ControlFlowRecursive-expected.txt @@ -3955,12 +3955,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ControlFlowRecursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ControlFlowRecursive.ets" } } }, @@ -3968,12 +3968,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ControlFlowRecursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ControlFlowRecursive.ets" } } }, @@ -3981,12 +3981,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ControlFlowRecursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ControlFlowRecursive.ets" } } }, diff --git a/ets2panda/test/parser/ets/Dollar_dollar_1-expected.txt b/ets2panda/test/parser/ets/Dollar_dollar_1-expected.txt index aea061a7ea..5caf5dd277 100644 --- a/ets2panda/test/parser/ets/Dollar_dollar_1-expected.txt +++ b/ets2panda/test/parser/ets/Dollar_dollar_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_1.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "Dollar_dollar_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 15, + "program": "Dollar_dollar_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "Dollar_dollar_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 15, + "program": "Dollar_dollar_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "Dollar_dollar_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 15, + "program": "Dollar_dollar_1.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "Dollar_dollar_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 15, "program": "Dollar_dollar_1.ets" } } diff --git a/ets2panda/test/parser/ets/Dollar_dollar_2-expected.txt b/ets2panda/test/parser/ets/Dollar_dollar_2-expected.txt index 76f3c0ef7f..9e4bd37922 100644 --- a/ets2panda/test/parser/ets/Dollar_dollar_2-expected.txt +++ b/ets2panda/test/parser/ets/Dollar_dollar_2-expected.txt @@ -1126,12 +1126,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" } } }, @@ -1139,12 +1139,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" } } }, @@ -1152,12 +1152,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" } } }, @@ -1232,12 +1232,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" } } }, @@ -1245,12 +1245,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" } } }, @@ -1258,12 +1258,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/Dollar_dollar_3-expected.txt b/ets2panda/test/parser/ets/Dollar_dollar_3-expected.txt index 071680734f..1320b38631 100644 --- a/ets2panda/test/parser/ets/Dollar_dollar_3-expected.txt +++ b/ets2panda/test/parser/ets/Dollar_dollar_3-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_3.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_3.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_3.ets" } } }, @@ -516,40 +516,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "Dollar_dollar_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "Dollar_dollar_3.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "Dollar_dollar_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "Dollar_dollar_3.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "Dollar_dollar_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "Dollar_dollar_3.ets" } } }, @@ -557,13 +557,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "Dollar_dollar_3.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "Dollar_dollar_3.ets" } } diff --git a/ets2panda/test/parser/ets/Dollar_dollar_4-expected.txt b/ets2panda/test/parser/ets/Dollar_dollar_4-expected.txt index 4ff5791c51..aa23adf4d8 100644 --- a/ets2panda/test/parser/ets/Dollar_dollar_4-expected.txt +++ b/ets2panda/test/parser/ets/Dollar_dollar_4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Dollar_dollar_4.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "Dollar_dollar_4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 16, + "program": "Dollar_dollar_4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "Dollar_dollar_4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 16, + "program": "Dollar_dollar_4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "Dollar_dollar_4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 16, + "program": "Dollar_dollar_4.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "Dollar_dollar_4.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 16, "program": "Dollar_dollar_4.ets" } } diff --git a/ets2panda/test/parser/ets/FunctionInSwitch-expected.txt b/ets2panda/test/parser/ets/FunctionInSwitch-expected.txt index 98281fa216..5d047a8903 100644 --- a/ets2panda/test/parser/ets/FunctionInSwitch-expected.txt +++ b/ets2panda/test/parser/ets/FunctionInSwitch-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionInSwitch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionInSwitch.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionInSwitch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionInSwitch.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionInSwitch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionInSwitch.ets" } } }, @@ -763,8 +763,8 @@ "program": "FunctionInSwitch.ets" }, "end": { - "line": 26, - "column": 17, + "line": 34, + "column": 6, "program": "FunctionInSwitch.ets" } } @@ -776,8 +776,8 @@ "program": "FunctionInSwitch.ets" }, "end": { - "line": 26, - "column": 17, + "line": 34, + "column": 6, "program": "FunctionInSwitch.ets" } } diff --git a/ets2panda/test/parser/ets/FunctionType-expected.txt b/ets2panda/test/parser/ets/FunctionType-expected.txt index 04d5fe044f..b2898c74e3 100644 --- a/ets2panda/test/parser/ets/FunctionType-expected.txt +++ b/ets2panda/test/parser/ets/FunctionType-expected.txt @@ -564,12 +564,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" } } }, @@ -577,12 +577,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" } } }, @@ -590,12 +590,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" } } }, @@ -670,12 +670,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" } } }, @@ -683,12 +683,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" } } }, @@ -696,12 +696,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionType.ets" } } }, diff --git a/ets2panda/test/parser/ets/FunctionalTypeAsTypeArgument-expected.txt b/ets2panda/test/parser/ets/FunctionalTypeAsTypeArgument-expected.txt index d2da9e851f..8f91514848 100644 --- a/ets2panda/test/parser/ets/FunctionalTypeAsTypeArgument-expected.txt +++ b/ets2panda/test/parser/ets/FunctionalTypeAsTypeArgument-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "FunctionalTypeAsTypeArgument.ets" } } }, diff --git a/ets2panda/test/parser/ets/InferTypeParamFromParam1-expected.txt b/ets2panda/test/parser/ets/InferTypeParamFromParam1-expected.txt index 15c3c280b2..4423a330e5 100644 --- a/ets2panda/test/parser/ets/InferTypeParamFromParam1-expected.txt +++ b/ets2panda/test/parser/ets/InferTypeParamFromParam1-expected.txt @@ -1887,12 +1887,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam1.ets" } } }, @@ -1900,12 +1900,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam1.ets" } } }, @@ -1913,12 +1913,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam1.ets" } } }, diff --git a/ets2panda/test/parser/ets/InferTypeParamFromParam3-expected.txt b/ets2panda/test/parser/ets/InferTypeParamFromParam3-expected.txt index 3847671d30..f043cd239e 100644 --- a/ets2panda/test/parser/ets/InferTypeParamFromParam3-expected.txt +++ b/ets2panda/test/parser/ets/InferTypeParamFromParam3-expected.txt @@ -2107,12 +2107,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam3.ets" } } }, @@ -2120,12 +2120,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam3.ets" } } }, @@ -2133,12 +2133,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "InferTypeParamFromParam3.ets" } } }, diff --git a/ets2panda/test/parser/ets/MathCordic-expected.txt b/ets2panda/test/parser/ets/MathCordic-expected.txt index 4d8698f428..ab95c14b41 100644 --- a/ets2panda/test/parser/ets/MathCordic-expected.txt +++ b/ets2panda/test/parser/ets/MathCordic-expected.txt @@ -6080,12 +6080,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathCordic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathCordic.ets" } } }, @@ -6093,12 +6093,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathCordic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathCordic.ets" } } }, @@ -6106,12 +6106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathCordic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathCordic.ets" } } }, diff --git a/ets2panda/test/parser/ets/MathPartialSums-expected.txt b/ets2panda/test/parser/ets/MathPartialSums-expected.txt index b69741c671..00abdda712 100644 --- a/ets2panda/test/parser/ets/MathPartialSums-expected.txt +++ b/ets2panda/test/parser/ets/MathPartialSums-expected.txt @@ -5436,12 +5436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathPartialSums.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathPartialSums.ets" } } }, @@ -5449,12 +5449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathPartialSums.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathPartialSums.ets" } } }, @@ -5462,12 +5462,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathPartialSums.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathPartialSums.ets" } } }, diff --git a/ets2panda/test/parser/ets/MathSpectralNorm-expected.txt b/ets2panda/test/parser/ets/MathSpectralNorm-expected.txt index df8d3ccb57..81b830b8f1 100644 --- a/ets2panda/test/parser/ets/MathSpectralNorm-expected.txt +++ b/ets2panda/test/parser/ets/MathSpectralNorm-expected.txt @@ -7191,12 +7191,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathSpectralNorm.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathSpectralNorm.ets" } } }, @@ -7204,12 +7204,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathSpectralNorm.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathSpectralNorm.ets" } } }, @@ -7217,12 +7217,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "MathSpectralNorm.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "MathSpectralNorm.ets" } } }, diff --git a/ets2panda/test/parser/ets/Morph3d-expected.txt b/ets2panda/test/parser/ets/Morph3d-expected.txt index 50edc7424b..35ffe6f119 100644 --- a/ets2panda/test/parser/ets/Morph3d-expected.txt +++ b/ets2panda/test/parser/ets/Morph3d-expected.txt @@ -3844,12 +3844,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Morph3d.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Morph3d.ets" } } }, @@ -3857,12 +3857,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Morph3d.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Morph3d.ets" } } }, @@ -3870,12 +3870,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Morph3d.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Morph3d.ets" } } }, diff --git a/ets2panda/test/parser/ets/OptionalParametersWithGenericReturnTypes-expected.txt b/ets2panda/test/parser/ets/OptionalParametersWithGenericReturnTypes-expected.txt index 4375ba7e0b..f87faf7eba 100644 --- a/ets2panda/test/parser/ets/OptionalParametersWithGenericReturnTypes-expected.txt +++ b/ets2panda/test/parser/ets/OptionalParametersWithGenericReturnTypes-expected.txt @@ -1527,12 +1527,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" } } }, @@ -1540,12 +1540,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" } } }, @@ -1553,12 +1553,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" } } }, @@ -1633,12 +1633,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" } } }, @@ -1646,12 +1646,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" } } }, @@ -1659,12 +1659,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "OptionalParametersWithGenericReturnTypes.ets" } } }, diff --git a/ets2panda/test/parser/ets/StaticFieldAndMethodSameName-expected.txt b/ets2panda/test/parser/ets/StaticFieldAndMethodSameName-expected.txt index 8f31f8f169..583a8f6d7d 100644 --- a/ets2panda/test/parser/ets/StaticFieldAndMethodSameName-expected.txt +++ b/ets2panda/test/parser/ets/StaticFieldAndMethodSameName-expected.txt @@ -459,12 +459,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameName.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameName.ets" } } }, @@ -472,12 +472,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameName.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameName.ets" } } }, @@ -485,12 +485,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameName.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameName.ets" } } }, diff --git a/ets2panda/test/parser/ets/StaticFieldAndMethodSameNameInheritance-expected.txt b/ets2panda/test/parser/ets/StaticFieldAndMethodSameNameInheritance-expected.txt index 25d1ccb545..02df1019bf 100644 --- a/ets2panda/test/parser/ets/StaticFieldAndMethodSameNameInheritance-expected.txt +++ b/ets2panda/test/parser/ets/StaticFieldAndMethodSameNameInheritance-expected.txt @@ -660,12 +660,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameNameInheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameNameInheritance.ets" } } }, @@ -673,12 +673,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameNameInheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameNameInheritance.ets" } } }, @@ -686,12 +686,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameNameInheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StaticFieldAndMethodSameNameInheritance.ets" } } }, diff --git a/ets2panda/test/parser/ets/StringBase64-expected.txt b/ets2panda/test/parser/ets/StringBase64-expected.txt index 2c100f3ec5..c1e0c5bbd1 100644 --- a/ets2panda/test/parser/ets/StringBase64-expected.txt +++ b/ets2panda/test/parser/ets/StringBase64-expected.txt @@ -10981,12 +10981,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StringBase64.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StringBase64.ets" } } }, @@ -10994,12 +10994,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StringBase64.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StringBase64.ets" } } }, @@ -11007,12 +11007,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "StringBase64.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "StringBase64.ets" } } }, diff --git a/ets2panda/test/parser/ets/access_modifier_2-expected.txt b/ets2panda/test/parser/ets/access_modifier_2-expected.txt index 156dc7a974..245eb1ec14 100644 --- a/ets2panda/test/parser/ets/access_modifier_2-expected.txt +++ b/ets2panda/test/parser/ets/access_modifier_2-expected.txt @@ -356,12 +356,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" } } }, @@ -369,12 +369,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" } } }, @@ -382,12 +382,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" } } }, @@ -462,12 +462,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" } } }, @@ -475,12 +475,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" } } }, @@ -488,12 +488,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/access_modifier_3-expected.txt b/ets2panda/test/parser/ets/access_modifier_3-expected.txt index ece74807b3..b6437f1f5e 100644 --- a/ets2panda/test/parser/ets/access_modifier_3-expected.txt +++ b/ets2panda/test/parser/ets/access_modifier_3-expected.txt @@ -290,12 +290,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" } } }, @@ -303,12 +303,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" } } }, @@ -316,12 +316,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" } } }, @@ -396,12 +396,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" } } }, @@ -409,12 +409,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" } } }, @@ -422,12 +422,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "access_modifier_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/ambient_call_signature-expected.txt b/ets2panda/test/parser/ets/ambient_call_signature-expected.txt index 6b165ea86e..2af8e374b2 100644 --- a/ets2panda/test/parser/ets/ambient_call_signature-expected.txt +++ b/ets2panda/test/parser/ets/ambient_call_signature-expected.txt @@ -453,12 +453,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_call_signature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_call_signature.ets" } } }, @@ -466,12 +466,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_call_signature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_call_signature.ets" } } }, @@ -479,12 +479,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_call_signature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_call_signature.ets" } } }, diff --git a/ets2panda/test/parser/ets/ambient_indexer_1-expected.txt b/ets2panda/test/parser/ets/ambient_indexer_1-expected.txt index a53827c724..41d45defc2 100644 --- a/ets2panda/test/parser/ets/ambient_indexer_1-expected.txt +++ b/ets2panda/test/parser/ets/ambient_indexer_1-expected.txt @@ -718,12 +718,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_1.ets" } } }, @@ -731,12 +731,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_1.ets" } } }, @@ -744,12 +744,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/ambient_indexer_6-expected.txt b/ets2panda/test/parser/ets/ambient_indexer_6-expected.txt index 030e8a4584..242e3acb78 100644 --- a/ets2panda/test/parser/ets/ambient_indexer_6-expected.txt +++ b/ets2panda/test/parser/ets/ambient_indexer_6-expected.txt @@ -718,12 +718,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_6.ets" } } }, @@ -731,12 +731,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_6.ets" } } }, @@ -744,12 +744,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_indexer_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/ambient_object_iterable-expected.txt b/ets2panda/test/parser/ets/ambient_object_iterable-expected.txt index e77ce84052..a0db035461 100644 --- a/ets2panda/test/parser/ets/ambient_object_iterable-expected.txt +++ b/ets2panda/test/parser/ets/ambient_object_iterable-expected.txt @@ -1216,12 +1216,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_object_iterable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_object_iterable.ets" } } }, @@ -1229,12 +1229,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_object_iterable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_object_iterable.ets" } } }, @@ -1242,12 +1242,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ambient_object_iterable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ambient_object_iterable.ets" } } }, diff --git a/ets2panda/test/parser/ets/array-expected.txt b/ets2panda/test/parser/ets/array-expected.txt index d47b76862c..0559cf8adc 100644 --- a/ets2panda/test/parser/ets/array-expected.txt +++ b/ets2panda/test/parser/ets/array-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array.ets" } } }, @@ -411,40 +411,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "array.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 34, + "program": "array.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "array.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 34, + "program": "array.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "array.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 34, + "program": "array.ets" } } }, @@ -452,13 +452,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "array.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 34, "program": "array.ets" } } diff --git a/ets2panda/test/parser/ets/arrayHoldingNullValue-expected.txt b/ets2panda/test/parser/ets/arrayHoldingNullValue-expected.txt index ed0c39d42a..1b4cbae517 100644 --- a/ets2panda/test/parser/ets/arrayHoldingNullValue-expected.txt +++ b/ets2panda/test/parser/ets/arrayHoldingNullValue-expected.txt @@ -271,40 +271,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "arrayHoldingNullValue.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 30, + "program": "arrayHoldingNullValue.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "arrayHoldingNullValue.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 30, + "program": "arrayHoldingNullValue.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "arrayHoldingNullValue.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 30, + "program": "arrayHoldingNullValue.ets" } } }, @@ -312,13 +312,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "arrayHoldingNullValue.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 30, "program": "arrayHoldingNullValue.ets" } } diff --git a/ets2panda/test/parser/ets/arrayLiteralReassign-expected.txt b/ets2panda/test/parser/ets/arrayLiteralReassign-expected.txt index b863fbac40..1ea8384ba8 100644 --- a/ets2panda/test/parser/ets/arrayLiteralReassign-expected.txt +++ b/ets2panda/test/parser/ets/arrayLiteralReassign-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrayLiteralReassign.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrayLiteralReassign.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrayLiteralReassign.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrayLiteralReassign.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "arrayLiteralReassign.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "arrayLiteralReassign.ets" } } }, diff --git a/ets2panda/test/parser/ets/array_creation_expression-expected.txt b/ets2panda/test/parser/ets/array_creation_expression-expected.txt index 087eb6530f..1a0fdd026e 100644 --- a/ets2panda/test/parser/ets/array_creation_expression-expected.txt +++ b/ets2panda/test/parser/ets/array_creation_expression-expected.txt @@ -1172,12 +1172,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_creation_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_creation_expression.ets" } } }, @@ -1185,12 +1185,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_creation_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_creation_expression.ets" } } }, @@ -1198,12 +1198,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_creation_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_creation_expression.ets" } } }, diff --git a/ets2panda/test/parser/ets/array_expression_implicit_cast_assignment-expected.txt b/ets2panda/test/parser/ets/array_expression_implicit_cast_assignment-expected.txt index c09c832b21..36b29615f1 100644 --- a/ets2panda/test/parser/ets/array_expression_implicit_cast_assignment-expected.txt +++ b/ets2panda/test/parser/ets/array_expression_implicit_cast_assignment-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_assignment.ets" } } }, diff --git a/ets2panda/test/parser/ets/array_expression_implicit_cast_return-expected.txt b/ets2panda/test/parser/ets/array_expression_implicit_cast_return-expected.txt index b01d4ec5a9..eddeef6b23 100644 --- a/ets2panda/test/parser/ets/array_expression_implicit_cast_return-expected.txt +++ b/ets2panda/test/parser/ets/array_expression_implicit_cast_return-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_expression_implicit_cast_return.ets" } } }, diff --git a/ets2panda/test/parser/ets/array_new-expected.txt b/ets2panda/test/parser/ets/array_new-expected.txt index e14e6cf7b6..7654424bc7 100644 --- a/ets2panda/test/parser/ets/array_new-expected.txt +++ b/ets2panda/test/parser/ets/array_new-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_new.ets" } } }, diff --git a/ets2panda/test/parser/ets/array_type_from_literal-expected.txt b/ets2panda/test/parser/ets/array_type_from_literal-expected.txt index 348b237ddb..f9f1bb2285 100644 --- a/ets2panda/test/parser/ets/array_type_from_literal-expected.txt +++ b/ets2panda/test/parser/ets/array_type_from_literal-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "array_type_from_literal.ets" } } }, diff --git a/ets2panda/test/parser/ets/as_expression_unary_expression-expected.txt b/ets2panda/test/parser/ets/as_expression_unary_expression-expected.txt index b375b4963c..77c49e0732 100644 --- a/ets2panda/test/parser/ets/as_expression_unary_expression-expected.txt +++ b/ets2panda/test/parser/ets/as_expression_unary_expression-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "as_expression_unary_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "as_expression_unary_expression.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "as_expression_unary_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "as_expression_unary_expression.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "as_expression_unary_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "as_expression_unary_expression.ets" } } }, diff --git a/ets2panda/test/parser/ets/assert-expected.txt b/ets2panda/test/parser/ets/assert-expected.txt index 282987a55d..669a90f286 100644 --- a/ets2panda/test/parser/ets/assert-expected.txt +++ b/ets2panda/test/parser/ets/assert-expected.txt @@ -1067,12 +1067,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" } } }, @@ -1080,12 +1080,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" } } }, @@ -1093,12 +1093,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" } } }, @@ -1173,12 +1173,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" } } }, @@ -1186,12 +1186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" } } }, @@ -1199,12 +1199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assert.ets" } } }, diff --git a/ets2panda/test/parser/ets/assign-expected.txt b/ets2panda/test/parser/ets/assign-expected.txt index 98ef7bde5d..c9fdcbfaba 100644 --- a/ets2panda/test/parser/ets/assign-expected.txt +++ b/ets2panda/test/parser/ets/assign-expected.txt @@ -143,40 +143,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "assign.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 10, + "program": "assign.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "assign.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 10, + "program": "assign.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "assign.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 10, + "program": "assign.ets" } } }, @@ -184,13 +184,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "assign.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 10, "program": "assign.ets" } } diff --git a/ets2panda/test/parser/ets/assign-func-expected.txt b/ets2panda/test/parser/ets/assign-func-expected.txt index 0f098d527b..9dbfe12b92 100644 --- a/ets2panda/test/parser/ets/assign-func-expected.txt +++ b/ets2panda/test/parser/ets/assign-func-expected.txt @@ -469,12 +469,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" } } }, @@ -482,12 +482,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" } } }, @@ -495,12 +495,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" } } }, @@ -575,12 +575,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" } } }, @@ -588,12 +588,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" } } }, @@ -601,12 +601,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assign-func.ets" } } }, diff --git a/ets2panda/test/parser/ets/assignNullableFromMethodToNullableParam-expected.txt b/ets2panda/test/parser/ets/assignNullableFromMethodToNullableParam-expected.txt index bd4085763f..63d8c1ba45 100644 --- a/ets2panda/test/parser/ets/assignNullableFromMethodToNullableParam-expected.txt +++ b/ets2panda/test/parser/ets/assignNullableFromMethodToNullableParam-expected.txt @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableFromMethodToNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableFromMethodToNullableParam.ets" } } }, @@ -512,12 +512,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableFromMethodToNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableFromMethodToNullableParam.ets" } } }, @@ -525,12 +525,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableFromMethodToNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableFromMethodToNullableParam.ets" } } }, diff --git a/ets2panda/test/parser/ets/assignNullableToNonNullable-expected.txt b/ets2panda/test/parser/ets/assignNullableToNonNullable-expected.txt index ef02e1816a..2aca76bfae 100644 --- a/ets2panda/test/parser/ets/assignNullableToNonNullable-expected.txt +++ b/ets2panda/test/parser/ets/assignNullableToNonNullable-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullable.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullable.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullable.ets" } } }, diff --git a/ets2panda/test/parser/ets/assignNullableToNonNullableArray-expected.txt b/ets2panda/test/parser/ets/assignNullableToNonNullableArray-expected.txt index bcd6041a94..42083111fb 100644 --- a/ets2panda/test/parser/ets/assignNullableToNonNullableArray-expected.txt +++ b/ets2panda/test/parser/ets/assignNullableToNonNullableArray-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableArray.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableArray.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableArray.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableArray.ets" } } }, diff --git a/ets2panda/test/parser/ets/assignNullableToNonNullableTypeAlias-expected.txt b/ets2panda/test/parser/ets/assignNullableToNonNullableTypeAlias-expected.txt index 3d1ab2fb66..6c337052f3 100644 --- a/ets2panda/test/parser/ets/assignNullableToNonNullableTypeAlias-expected.txt +++ b/ets2panda/test/parser/ets/assignNullableToNonNullableTypeAlias-expected.txt @@ -346,12 +346,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableTypeAlias.ets" } } }, @@ -359,12 +359,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableTypeAlias.ets" } } }, @@ -372,12 +372,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignNullableToNonNullableTypeAlias.ets" } } }, diff --git a/ets2panda/test/parser/ets/assignments-expected.txt b/ets2panda/test/parser/ets/assignments-expected.txt index 960e551480..d2f2cbdfc7 100644 --- a/ets2panda/test/parser/ets/assignments-expected.txt +++ b/ets2panda/test/parser/ets/assignments-expected.txt @@ -1972,12 +1972,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" } } }, @@ -1985,12 +1985,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" } } }, @@ -1998,12 +1998,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" } } }, @@ -2078,12 +2078,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" } } }, @@ -2091,12 +2091,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" } } }, @@ -2104,12 +2104,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "assignments.ets" } } }, diff --git a/ets2panda/test/parser/ets/async_func_return_type-expected.txt b/ets2panda/test/parser/ets/async_func_return_type-expected.txt index 8124a42ce8..79eae8cee4 100644 --- a/ets2panda/test/parser/ets/async_func_return_type-expected.txt +++ b/ets2panda/test/parser/ets/async_func_return_type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_func_return_type.ets" } } }, diff --git a/ets2panda/test/parser/ets/async_function-expected.txt b/ets2panda/test/parser/ets/async_function-expected.txt index c1469202d4..07c34ec1ac 100644 --- a/ets2panda/test/parser/ets/async_function-expected.txt +++ b/ets2panda/test/parser/ets/async_function-expected.txt @@ -516,12 +516,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_function.ets" } } }, @@ -529,12 +529,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_function.ets" } } }, @@ -542,12 +542,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_function.ets" } } }, @@ -895,40 +895,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "async_function.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 96, + "program": "async_function.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "async_function.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 96, + "program": "async_function.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "async_function.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 96, + "program": "async_function.ets" } } }, @@ -936,13 +936,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 22, + "column": 5, "program": "async_function.ets" }, "end": { - "line": 1, - "column": 1, + "line": 22, + "column": 96, "program": "async_function.ets" } } diff --git a/ets2panda/test/parser/ets/async_overload-expected.txt b/ets2panda/test/parser/ets/async_overload-expected.txt index 59d04c9e13..ca6a8d918f 100644 --- a/ets2panda/test/parser/ets/async_overload-expected.txt +++ b/ets2panda/test/parser/ets/async_overload-expected.txt @@ -973,12 +973,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_overload.ets" } } }, @@ -986,12 +986,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_overload.ets" } } }, @@ -999,12 +999,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_overload.ets" } } }, diff --git a/ets2panda/test/parser/ets/async_with_lambda-expected.txt b/ets2panda/test/parser/ets/async_with_lambda-expected.txt index caaaa0ae22..9e47c47d77 100644 --- a/ets2panda/test/parser/ets/async_with_lambda-expected.txt +++ b/ets2panda/test/parser/ets/async_with_lambda-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "async_with_lambda.ets" } } }, diff --git a/ets2panda/test/parser/ets/await_complex_promise-expected.txt b/ets2panda/test/parser/ets/await_complex_promise-expected.txt index 401533bb22..1b5b00439c 100644 --- a/ets2panda/test/parser/ets/await_complex_promise-expected.txt +++ b/ets2panda/test/parser/ets/await_complex_promise-expected.txt @@ -287,12 +287,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" } } }, @@ -300,12 +300,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" } } }, @@ -313,12 +313,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" } } }, @@ -393,12 +393,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" } } }, @@ -406,12 +406,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" } } }, @@ -419,12 +419,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_complex_promise.ets" } } }, diff --git a/ets2panda/test/parser/ets/await_keyword-expected.txt b/ets2panda/test/parser/ets/await_keyword-expected.txt index 57cd2bae08..250f778f45 100644 --- a/ets2panda/test/parser/ets/await_keyword-expected.txt +++ b/ets2panda/test/parser/ets/await_keyword-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_keyword.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_keyword.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "await_keyword.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "await_keyword.ets" } } }, @@ -2086,40 +2086,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "await_keyword.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 39, + "column": 40, + "program": "await_keyword.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "await_keyword.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 39, + "column": 40, + "program": "await_keyword.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "await_keyword.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 39, + "column": 40, + "program": "await_keyword.ets" } } }, @@ -2127,13 +2127,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 22, + "column": 5, "program": "await_keyword.ets" }, "end": { - "line": 1, - "column": 1, + "line": 39, + "column": 40, "program": "await_keyword.ets" } } diff --git a/ets2panda/test/parser/ets/binary_op-expected.txt b/ets2panda/test/parser/ets/binary_op-expected.txt index 66494fa2c3..f4bf9db30e 100644 --- a/ets2panda/test/parser/ets/binary_op-expected.txt +++ b/ets2panda/test/parser/ets/binary_op-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_op.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_op.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_op.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_op.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_op.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_op.ets" } } }, @@ -5790,40 +5790,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "binary_op.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 77, + "column": 34, + "program": "binary_op.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "binary_op.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 77, + "column": 34, + "program": "binary_op.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "binary_op.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 77, + "column": 34, + "program": "binary_op.ets" } } }, @@ -5831,13 +5831,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "binary_op.ets" }, "end": { - "line": 1, - "column": 1, + "line": 77, + "column": 34, "program": "binary_op.ets" } } diff --git a/ets2panda/test/parser/ets/binary_operations-expected.txt b/ets2panda/test/parser/ets/binary_operations-expected.txt index e456b8b907..e74bc20467 100644 --- a/ets2panda/test/parser/ets/binary_operations-expected.txt +++ b/ets2panda/test/parser/ets/binary_operations-expected.txt @@ -1939,12 +1939,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" } } }, @@ -1952,12 +1952,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" } } }, @@ -1965,12 +1965,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" } } }, @@ -2045,12 +2045,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" } } }, @@ -2058,12 +2058,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" } } }, @@ -2071,12 +2071,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "binary_operations.ets" } } }, diff --git a/ets2panda/test/parser/ets/blocks-expected.txt b/ets2panda/test/parser/ets/blocks-expected.txt index 8e49225a66..5d037504e5 100644 --- a/ets2panda/test/parser/ets/blocks-expected.txt +++ b/ets2panda/test/parser/ets/blocks-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "blocks.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "blocks.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "blocks.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "blocks.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "blocks.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "blocks.ets" } } }, @@ -367,40 +367,40 @@ ], "loc": { "start": { - "line": 1, + "line": 17, "column": 1, - "program": null + "program": "blocks.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 2, + "program": "blocks.ets" } } }, "loc": { "start": { - "line": 1, + "line": 17, "column": 1, - "program": null + "program": "blocks.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 2, + "program": "blocks.ets" } } }, "loc": { "start": { - "line": 1, + "line": 17, "column": 1, - "program": null + "program": "blocks.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 23, + "column": 2, + "program": "blocks.ets" } } }, @@ -408,13 +408,13 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 17, "column": 1, "program": "blocks.ets" }, "end": { - "line": 1, - "column": 1, + "line": 23, + "column": 2, "program": "blocks.ets" } } diff --git a/ets2panda/test/parser/ets/blocks_scopes-expected.txt b/ets2panda/test/parser/ets/blocks_scopes-expected.txt index e2b72d6192..33730ccfec 100644 --- a/ets2panda/test/parser/ets/blocks_scopes-expected.txt +++ b/ets2panda/test/parser/ets/blocks_scopes-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "blocks_scopes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "blocks_scopes.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "blocks_scopes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "blocks_scopes.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "blocks_scopes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "blocks_scopes.ets" } } }, @@ -516,40 +516,40 @@ ], "loc": { "start": { - "line": 1, + "line": 17, "column": 1, - "program": null + "program": "blocks_scopes.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 26, + "column": 2, + "program": "blocks_scopes.ets" } } }, "loc": { "start": { - "line": 1, + "line": 17, "column": 1, - "program": null + "program": "blocks_scopes.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 26, + "column": 2, + "program": "blocks_scopes.ets" } } }, "loc": { "start": { - "line": 1, + "line": 17, "column": 1, - "program": null + "program": "blocks_scopes.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 26, + "column": 2, + "program": "blocks_scopes.ets" } } }, @@ -557,13 +557,13 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 17, "column": 1, "program": "blocks_scopes.ets" }, "end": { - "line": 1, - "column": 1, + "line": 26, + "column": 2, "program": "blocks_scopes.ets" } } diff --git a/ets2panda/test/parser/ets/boolean-expected.txt b/ets2panda/test/parser/ets/boolean-expected.txt index 152eb7b11c..f33849578b 100644 --- a/ets2panda/test/parser/ets/boolean-expected.txt +++ b/ets2panda/test/parser/ets/boolean-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boolean.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 22, + "program": "boolean.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boolean.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 22, + "program": "boolean.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "boolean.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 22, + "program": "boolean.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "boolean.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 22, "program": "boolean.ets" } } diff --git a/ets2panda/test/parser/ets/boolean_cond-expected.txt b/ets2panda/test/parser/ets/boolean_cond-expected.txt index f498e6d0d0..97a76c166f 100644 --- a/ets2panda/test/parser/ets/boolean_cond-expected.txt +++ b/ets2panda/test/parser/ets/boolean_cond-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean_cond.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean_cond.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean_cond.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean_cond.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean_cond.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean_cond.ets" } } }, diff --git a/ets2panda/test/parser/ets/boolean_default-expected.txt b/ets2panda/test/parser/ets/boolean_default-expected.txt index fe91f0889b..c0bfe203bc 100644 --- a/ets2panda/test/parser/ets/boolean_default-expected.txt +++ b/ets2panda/test/parser/ets/boolean_default-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean_default.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean_default.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean_default.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean_default.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "boolean_default.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "boolean_default.ets" } } }, diff --git a/ets2panda/test/parser/ets/break-expected.txt b/ets2panda/test/parser/ets/break-expected.txt index ca822b37c2..f3879d3ce1 100644 --- a/ets2panda/test/parser/ets/break-expected.txt +++ b/ets2panda/test/parser/ets/break-expected.txt @@ -192,40 +192,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "break.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "break.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "break.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "break.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "break.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "break.ets" } } }, @@ -233,13 +233,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "break.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 25, "program": "break.ets" } } diff --git a/ets2panda/test/parser/ets/callFunctionWithNullableParam-expected.txt b/ets2panda/test/parser/ets/callFunctionWithNullableParam-expected.txt index c7299e7b67..343d19a3ed 100644 --- a/ets2panda/test/parser/ets/callFunctionWithNullableParam-expected.txt +++ b/ets2panda/test/parser/ets/callFunctionWithNullableParam-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callFunctionWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callFunctionWithNullableParam.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callFunctionWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callFunctionWithNullableParam.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callFunctionWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callFunctionWithNullableParam.ets" } } }, diff --git a/ets2panda/test/parser/ets/callInterfaceMethodWithNullableParam-expected.txt b/ets2panda/test/parser/ets/callInterfaceMethodWithNullableParam-expected.txt index 9fdfdd0562..5d016867aa 100644 --- a/ets2panda/test/parser/ets/callInterfaceMethodWithNullableParam-expected.txt +++ b/ets2panda/test/parser/ets/callInterfaceMethodWithNullableParam-expected.txt @@ -734,12 +734,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callInterfaceMethodWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callInterfaceMethodWithNullableParam.ets" } } }, @@ -747,12 +747,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callInterfaceMethodWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callInterfaceMethodWithNullableParam.ets" } } }, @@ -760,12 +760,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callInterfaceMethodWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callInterfaceMethodWithNullableParam.ets" } } }, diff --git a/ets2panda/test/parser/ets/callMethodWithNullableParam-expected.txt b/ets2panda/test/parser/ets/callMethodWithNullableParam-expected.txt index bde159a6ec..235762958a 100644 --- a/ets2panda/test/parser/ets/callMethodWithNullableParam-expected.txt +++ b/ets2panda/test/parser/ets/callMethodWithNullableParam-expected.txt @@ -436,12 +436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callMethodWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callMethodWithNullableParam.ets" } } }, @@ -449,12 +449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callMethodWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callMethodWithNullableParam.ets" } } }, @@ -462,12 +462,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "callMethodWithNullableParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "callMethodWithNullableParam.ets" } } }, diff --git a/ets2panda/test/parser/ets/calling_superclass_methods-expected.txt b/ets2panda/test/parser/ets/calling_superclass_methods-expected.txt index 230b38802f..084c4c27f5 100644 --- a/ets2panda/test/parser/ets/calling_superclass_methods-expected.txt +++ b/ets2panda/test/parser/ets/calling_superclass_methods-expected.txt @@ -745,12 +745,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" } } }, @@ -758,12 +758,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" } } }, @@ -771,12 +771,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" } } }, @@ -851,12 +851,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" } } }, @@ -864,12 +864,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" } } }, @@ -877,12 +877,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "calling_superclass_methods.ets" } } }, diff --git a/ets2panda/test/parser/ets/cast_const_union-expected.txt b/ets2panda/test/parser/ets/cast_const_union-expected.txt index 9052241572..00e5e90655 100644 --- a/ets2panda/test/parser/ets/cast_const_union-expected.txt +++ b/ets2panda/test/parser/ets/cast_const_union-expected.txt @@ -207,40 +207,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "cast_const_union.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 9, + "program": "cast_const_union.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "cast_const_union.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 9, + "program": "cast_const_union.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "cast_const_union.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 9, + "program": "cast_const_union.ets" } } }, @@ -248,13 +248,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "cast_const_union.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 9, "program": "cast_const_union.ets" } } diff --git a/ets2panda/test/parser/ets/cast_expressions-expected.txt b/ets2panda/test/parser/ets/cast_expressions-expected.txt index b72e0665a8..e7994f26c0 100644 --- a/ets2panda/test/parser/ets/cast_expressions-expected.txt +++ b/ets2panda/test/parser/ets/cast_expressions-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions.ets" } } }, diff --git a/ets2panda/test/parser/ets/cast_expressions3-expected.txt b/ets2panda/test/parser/ets/cast_expressions3-expected.txt index 9f0475e40e..b21a1e97b3 100644 --- a/ets2panda/test/parser/ets/cast_expressions3-expected.txt +++ b/ets2panda/test/parser/ets/cast_expressions3-expected.txt @@ -749,12 +749,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" } } }, @@ -762,12 +762,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" } } }, @@ -775,12 +775,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" } } }, @@ -855,12 +855,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" } } }, @@ -868,12 +868,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" } } }, @@ -881,12 +881,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions3.ets" } } }, diff --git a/ets2panda/test/parser/ets/cast_expressions4-expected.txt b/ets2panda/test/parser/ets/cast_expressions4-expected.txt index 51ea1f1732..8241915ac0 100644 --- a/ets2panda/test/parser/ets/cast_expressions4-expected.txt +++ b/ets2panda/test/parser/ets/cast_expressions4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions4.ets" } } }, diff --git a/ets2panda/test/parser/ets/cast_expressions5-expected.txt b/ets2panda/test/parser/ets/cast_expressions5-expected.txt index ab9a22576b..4f98ac702e 100644 --- a/ets2panda/test/parser/ets/cast_expressions5-expected.txt +++ b/ets2panda/test/parser/ets/cast_expressions5-expected.txt @@ -748,12 +748,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions5.ets" } } }, @@ -761,12 +761,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions5.ets" } } }, @@ -774,12 +774,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "cast_expressions5.ets" } } }, @@ -917,40 +917,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "cast_expressions5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "cast_expressions5.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "cast_expressions5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "cast_expressions5.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "cast_expressions5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "cast_expressions5.ets" } } }, @@ -958,13 +958,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "cast_expressions5.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 25, "program": "cast_expressions5.ets" } } diff --git a/ets2panda/test/parser/ets/class_init-expected.txt b/ets2panda/test/parser/ets/class_init-expected.txt index e5d69c29a6..5f0d248f14 100644 --- a/ets2panda/test/parser/ets/class_init-expected.txt +++ b/ets2panda/test/parser/ets/class_init-expected.txt @@ -471,12 +471,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" } } }, @@ -484,12 +484,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" } } }, @@ -497,12 +497,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" } } }, @@ -577,12 +577,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" } } }, @@ -590,12 +590,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" } } }, @@ -603,12 +603,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_init.ets" } } }, diff --git a/ets2panda/test/parser/ets/class_instance-expected.txt b/ets2panda/test/parser/ets/class_instance-expected.txt index e8c78b56b7..d67f34a88f 100644 --- a/ets2panda/test/parser/ets/class_instance-expected.txt +++ b/ets2panda/test/parser/ets/class_instance-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance.ets" } } }, @@ -685,40 +685,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "class_instance.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 29, + "program": "class_instance.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "class_instance.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 29, + "program": "class_instance.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "class_instance.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 29, + "program": "class_instance.ets" } } }, @@ -726,13 +726,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "class_instance.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 29, "program": "class_instance.ets" } } diff --git a/ets2panda/test/parser/ets/class_instance_creation-expected.txt b/ets2panda/test/parser/ets/class_instance_creation-expected.txt index e1b669124b..39e1e72cc1 100644 --- a/ets2panda/test/parser/ets/class_instance_creation-expected.txt +++ b/ets2panda/test/parser/ets/class_instance_creation-expected.txt @@ -1124,12 +1124,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" } } }, @@ -1137,12 +1137,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" } } }, @@ -1150,12 +1150,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" } } }, @@ -1230,12 +1230,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" } } }, @@ -1243,12 +1243,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" } } }, @@ -1256,12 +1256,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_creation.ets" } } }, diff --git a/ets2panda/test/parser/ets/class_instance_import_alias-expected.txt b/ets2panda/test/parser/ets/class_instance_import_alias-expected.txt index af67a5ec66..31cfa717b7 100644 --- a/ets2panda/test/parser/ets/class_instance_import_alias-expected.txt +++ b/ets2panda/test/parser/ets/class_instance_import_alias-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_import_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_import_alias.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_import_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_import_alias.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_import_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_import_alias.ets" } } }, diff --git a/ets2panda/test/parser/ets/class_instance_initializer-expected.txt b/ets2panda/test/parser/ets/class_instance_initializer-expected.txt index e1b5d92d37..d02a3786fc 100644 --- a/ets2panda/test/parser/ets/class_instance_initializer-expected.txt +++ b/ets2panda/test/parser/ets/class_instance_initializer-expected.txt @@ -3488,12 +3488,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" } } }, @@ -3501,12 +3501,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" } } }, @@ -3514,12 +3514,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" } } }, @@ -3594,12 +3594,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" } } }, @@ -3607,12 +3607,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" } } }, @@ -3620,12 +3620,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_instance_initializer.ets" } } }, diff --git a/ets2panda/test/parser/ets/class_interface_enum_only_top_level_4-expected.txt b/ets2panda/test/parser/ets/class_interface_enum_only_top_level_4-expected.txt index 877b11b3cb..57a2f46f99 100644 --- a/ets2panda/test/parser/ets/class_interface_enum_only_top_level_4-expected.txt +++ b/ets2panda/test/parser/ets/class_interface_enum_only_top_level_4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_interface_enum_only_top_level_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_interface_enum_only_top_level_4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_interface_enum_only_top_level_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_interface_enum_only_top_level_4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_interface_enum_only_top_level_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_interface_enum_only_top_level_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/class_static_initializer-expected.txt b/ets2panda/test/parser/ets/class_static_initializer-expected.txt index 524a1ac1b9..d9e54d9222 100644 --- a/ets2panda/test/parser/ets/class_static_initializer-expected.txt +++ b/ets2panda/test/parser/ets/class_static_initializer-expected.txt @@ -852,12 +852,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" } } }, @@ -865,12 +865,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" } } }, @@ -878,12 +878,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" } } }, @@ -958,12 +958,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" } } }, @@ -971,12 +971,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" } } }, @@ -984,12 +984,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_static_initializer.ets" } } }, diff --git a/ets2panda/test/parser/ets/classes-expected.txt b/ets2panda/test/parser/ets/classes-expected.txt index 36eb887b8e..264010ea53 100644 --- a/ets2panda/test/parser/ets/classes-expected.txt +++ b/ets2panda/test/parser/ets/classes-expected.txt @@ -746,12 +746,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" } } }, @@ -759,12 +759,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" } } }, @@ -772,12 +772,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" } } }, @@ -852,12 +852,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" } } }, @@ -865,12 +865,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" } } }, @@ -878,12 +878,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classes.ets" } } }, diff --git a/ets2panda/test/parser/ets/comment_block-expected.txt b/ets2panda/test/parser/ets/comment_block-expected.txt index 5d584272a8..e15e80b28d 100644 --- a/ets2panda/test/parser/ets/comment_block-expected.txt +++ b/ets2panda/test/parser/ets/comment_block-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_block.ets" } } }, diff --git a/ets2panda/test/parser/ets/comment_line-expected.txt b/ets2panda/test/parser/ets/comment_line-expected.txt index 6359231213..c2729f70bf 100644 --- a/ets2panda/test/parser/ets/comment_line-expected.txt +++ b/ets2panda/test/parser/ets/comment_line-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "comment_line.ets" } } }, diff --git a/ets2panda/test/parser/ets/conditionalExpressionType-expected.txt b/ets2panda/test/parser/ets/conditionalExpressionType-expected.txt index 8783d8a8ca..ea9efc5753 100644 --- a/ets2panda/test/parser/ets/conditionalExpressionType-expected.txt +++ b/ets2panda/test/parser/ets/conditionalExpressionType-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conditionalExpressionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conditionalExpressionType.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conditionalExpressionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conditionalExpressionType.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conditionalExpressionType.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conditionalExpressionType.ets" } } }, diff --git a/ets2panda/test/parser/ets/const-expected.txt b/ets2panda/test/parser/ets/const-expected.txt index d4eb5c420c..5e04fa1841 100644 --- a/ets2panda/test/parser/ets/const-expected.txt +++ b/ets2panda/test/parser/ets/const-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "const.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "const.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "const.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "const.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "const.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "const.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "const.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "const.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "const.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "const.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "const.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "const.ets" } } }, diff --git a/ets2panda/test/parser/ets/constructorThrowsRethrows-expected.txt b/ets2panda/test/parser/ets/constructorThrowsRethrows-expected.txt index b4ef5220f5..fc27d4a34e 100644 --- a/ets2panda/test/parser/ets/constructorThrowsRethrows-expected.txt +++ b/ets2panda/test/parser/ets/constructorThrowsRethrows-expected.txt @@ -554,12 +554,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" } } }, @@ -567,12 +567,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" } } }, @@ -580,12 +580,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" } } }, @@ -660,12 +660,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" } } }, @@ -673,12 +673,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" } } }, @@ -686,12 +686,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructorThrowsRethrows.ets" } } }, diff --git a/ets2panda/test/parser/ets/constructor_super_call1-expected.txt b/ets2panda/test/parser/ets/constructor_super_call1-expected.txt index a4bad5265d..a3b865478e 100644 --- a/ets2panda/test/parser/ets/constructor_super_call1-expected.txt +++ b/ets2panda/test/parser/ets/constructor_super_call1-expected.txt @@ -772,12 +772,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" } } }, @@ -785,12 +785,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" } } }, @@ -798,12 +798,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" } } }, @@ -878,12 +878,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" } } }, @@ -891,12 +891,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" } } }, @@ -904,12 +904,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call1.ets" } } }, diff --git a/ets2panda/test/parser/ets/constructor_super_call3-expected.txt b/ets2panda/test/parser/ets/constructor_super_call3-expected.txt index 2f33fcc0e0..e3d4a31ae3 100644 --- a/ets2panda/test/parser/ets/constructor_super_call3-expected.txt +++ b/ets2panda/test/parser/ets/constructor_super_call3-expected.txt @@ -486,12 +486,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" } } }, @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" } } }, @@ -512,12 +512,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" } } }, @@ -592,12 +592,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" } } }, @@ -605,12 +605,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" } } }, @@ -618,12 +618,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_super_call3.ets" } } }, diff --git a/ets2panda/test/parser/ets/constructor_test-expected.txt b/ets2panda/test/parser/ets/constructor_test-expected.txt index 1f51245e9f..3350e9aab7 100644 --- a/ets2panda/test/parser/ets/constructor_test-expected.txt +++ b/ets2panda/test/parser/ets/constructor_test-expected.txt @@ -1224,12 +1224,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" } } }, @@ -1237,12 +1237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" } } }, @@ -1250,12 +1250,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" } } }, @@ -1330,12 +1330,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" } } }, @@ -1343,12 +1343,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" } } }, @@ -1356,12 +1356,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_test.ets" } } }, diff --git a/ets2panda/test/parser/ets/constructor_with_return_2-expected.txt b/ets2panda/test/parser/ets/constructor_with_return_2-expected.txt index 362d6bee8a..2474670e69 100644 --- a/ets2panda/test/parser/ets/constructor_with_return_2-expected.txt +++ b/ets2panda/test/parser/ets/constructor_with_return_2-expected.txt @@ -404,12 +404,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" } } }, @@ -417,12 +417,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" } } }, @@ -430,12 +430,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" } } }, @@ -510,12 +510,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" } } }, @@ -523,12 +523,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" } } }, @@ -536,12 +536,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "constructor_with_return_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/continue-expected.txt b/ets2panda/test/parser/ets/continue-expected.txt index 235c278afe..d28fae802d 100644 --- a/ets2panda/test/parser/ets/continue-expected.txt +++ b/ets2panda/test/parser/ets/continue-expected.txt @@ -192,40 +192,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "continue.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "continue.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "continue.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "continue.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "continue.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "continue.ets" } } }, @@ -233,13 +233,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "continue.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 25, "program": "continue.ets" } } diff --git a/ets2panda/test/parser/ets/conversions-expected.txt b/ets2panda/test/parser/ets/conversions-expected.txt index de9e873fde..4108a9fc06 100644 --- a/ets2panda/test/parser/ets/conversions-expected.txt +++ b/ets2panda/test/parser/ets/conversions-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversions.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversions.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "conversions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "conversions.ets" } } }, diff --git a/ets2panda/test/parser/ets/decl_infer-expected.txt b/ets2panda/test/parser/ets/decl_infer-expected.txt index d019542239..f0a6e3abfe 100644 --- a/ets2panda/test/parser/ets/decl_infer-expected.txt +++ b/ets2panda/test/parser/ets/decl_infer-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "decl_infer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "decl_infer.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "decl_infer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "decl_infer.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "decl_infer.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "decl_infer.ets" } } }, @@ -505,40 +505,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "decl_infer.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 15, + "program": "decl_infer.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "decl_infer.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 15, + "program": "decl_infer.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "decl_infer.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 15, + "program": "decl_infer.ets" } } }, @@ -546,13 +546,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "decl_infer.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 15, "program": "decl_infer.ets" } } diff --git a/ets2panda/test/parser/ets/declare_ambient_const_variable-expected.txt b/ets2panda/test/parser/ets/declare_ambient_const_variable-expected.txt index 823de09dd3..cf14e29753 100644 --- a/ets2panda/test/parser/ets/declare_ambient_const_variable-expected.txt +++ b/ets2panda/test/parser/ets/declare_ambient_const_variable-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "declare_ambient_const_variable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "declare_ambient_const_variable.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "declare_ambient_const_variable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "declare_ambient_const_variable.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "declare_ambient_const_variable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "declare_ambient_const_variable.ets" } } }, diff --git a/ets2panda/test/parser/ets/default_parameter10-expected.txt b/ets2panda/test/parser/ets/default_parameter10-expected.txt index 1dd365944b..26d1df2fb9 100644 --- a/ets2panda/test/parser/ets/default_parameter10-expected.txt +++ b/ets2panda/test/parser/ets/default_parameter10-expected.txt @@ -619,12 +619,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter10.ets" } } }, @@ -632,12 +632,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter10.ets" } } }, @@ -645,12 +645,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter10.ets" } } }, diff --git a/ets2panda/test/parser/ets/default_parameter5-expected.txt b/ets2panda/test/parser/ets/default_parameter5-expected.txt index f3e2bfa544..ce56595f02 100644 --- a/ets2panda/test/parser/ets/default_parameter5-expected.txt +++ b/ets2panda/test/parser/ets/default_parameter5-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter5.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter5.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter5.ets" } } }, diff --git a/ets2panda/test/parser/ets/default_parameter7-expected.txt b/ets2panda/test/parser/ets/default_parameter7-expected.txt index 1e2089524a..3a86fd3bd3 100644 --- a/ets2panda/test/parser/ets/default_parameter7-expected.txt +++ b/ets2panda/test/parser/ets/default_parameter7-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter7.ets" } } }, diff --git a/ets2panda/test/parser/ets/default_parameter9-expected.txt b/ets2panda/test/parser/ets/default_parameter9-expected.txt index 3ac72d8cf3..bdfd77d587 100644 --- a/ets2panda/test/parser/ets/default_parameter9-expected.txt +++ b/ets2panda/test/parser/ets/default_parameter9-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter9.ets" } } }, diff --git a/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt b/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt index b8edf0fab3..1115ac77c6 100644 --- a/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt +++ b/ets2panda/test/parser/ets/default_parameter_implicitly_typed_return_void-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter_implicitly_typed_return_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter_implicitly_typed_return_void.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter_implicitly_typed_return_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter_implicitly_typed_return_void.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_parameter_implicitly_typed_return_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_parameter_implicitly_typed_return_void.ets" } } }, diff --git a/ets2panda/test/parser/ets/dynamic_import_tests/dynamic_optional_decl-expected.txt b/ets2panda/test/parser/ets/dynamic_import_tests/dynamic_optional_decl-expected.txt index b15e5f1c09..094e6f07e0 100644 --- a/ets2panda/test/parser/ets/dynamic_import_tests/dynamic_optional_decl-expected.txt +++ b/ets2panda/test/parser/ets/dynamic_import_tests/dynamic_optional_decl-expected.txt @@ -211,12 +211,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "dynamic_optional_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "dynamic_optional_decl.ets" } } }, @@ -224,12 +224,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "dynamic_optional_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "dynamic_optional_decl.ets" } } }, @@ -237,12 +237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "dynamic_optional_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "dynamic_optional_decl.ets" } } }, diff --git a/ets2panda/test/parser/ets/empty_class-expected.txt b/ets2panda/test/parser/ets/empty_class-expected.txt index f5870a749a..59f82bdf0f 100644 --- a/ets2panda/test/parser/ets/empty_class-expected.txt +++ b/ets2panda/test/parser/ets/empty_class-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_class.ets" } } }, diff --git a/ets2panda/test/parser/ets/empty_statement-expected.txt b/ets2panda/test/parser/ets/empty_statement-expected.txt index 94c8bbdbc0..b943d266bf 100644 --- a/ets2panda/test/parser/ets/empty_statement-expected.txt +++ b/ets2panda/test/parser/ets/empty_statement-expected.txt @@ -937,12 +937,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" } } }, @@ -950,12 +950,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" } } }, @@ -963,12 +963,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" } } }, @@ -1043,12 +1043,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" } } }, @@ -1056,12 +1056,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" } } }, @@ -1069,12 +1069,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "empty_statement.ets" } } }, diff --git a/ets2panda/test/parser/ets/exports-expected.txt b/ets2panda/test/parser/ets/exports-expected.txt index 774017d3bb..115ec532d3 100644 --- a/ets2panda/test/parser/ets/exports-expected.txt +++ b/ets2panda/test/parser/ets/exports-expected.txt @@ -331,12 +331,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "exports.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "exports.ets" } } }, @@ -344,12 +344,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "exports.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "exports.ets" } } }, @@ -357,12 +357,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "exports.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "exports.ets" } } }, @@ -500,40 +500,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "exports.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 18, + "program": "exports.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "exports.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 18, + "program": "exports.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "exports.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 18, + "program": "exports.ets" } } }, @@ -541,13 +541,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "exports.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 18, "program": "exports.ets" } } diff --git a/ets2panda/test/parser/ets/external_cyclic_constructor_check-expected.txt b/ets2panda/test/parser/ets/external_cyclic_constructor_check-expected.txt index 4cee1d6d40..6062aa7e88 100644 --- a/ets2panda/test/parser/ets/external_cyclic_constructor_check-expected.txt +++ b/ets2panda/test/parser/ets/external_cyclic_constructor_check-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "external_cyclic_constructor_check.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "external_cyclic_constructor_check.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "external_cyclic_constructor_check.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "external_cyclic_constructor_check.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "external_cyclic_constructor_check.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "external_cyclic_constructor_check.ets" } } }, diff --git a/ets2panda/test/parser/ets/field_decl-expected.txt b/ets2panda/test/parser/ets/field_decl-expected.txt index 689727a8d8..b13048343f 100644 --- a/ets2panda/test/parser/ets/field_decl-expected.txt +++ b/ets2panda/test/parser/ets/field_decl-expected.txt @@ -810,12 +810,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" } } }, @@ -823,12 +823,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" } } }, @@ -836,12 +836,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" } } }, @@ -916,12 +916,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" } } }, @@ -929,12 +929,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" } } }, @@ -942,12 +942,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "field_decl.ets" } } }, diff --git a/ets2panda/test/parser/ets/final_empty_class-expected.txt b/ets2panda/test/parser/ets/final_empty_class-expected.txt index 81ad39aa37..cb234dfcc6 100644 --- a/ets2panda/test/parser/ets/final_empty_class-expected.txt +++ b/ets2panda/test/parser/ets/final_empty_class-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "final_empty_class.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_1-expected.txt b/ets2panda/test/parser/ets/float_pont_format_1-expected.txt index 8fe9b1e996..9f2fe9f579 100644 --- a/ets2panda/test/parser/ets/float_pont_format_1-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_2-expected.txt b/ets2panda/test/parser/ets/float_pont_format_2-expected.txt index bec8dfd030..d5bb53cff2 100644 --- a/ets2panda/test/parser/ets/float_pont_format_2-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_3-expected.txt b/ets2panda/test/parser/ets/float_pont_format_3-expected.txt index 7ed81174d5..308d54d681 100644 --- a/ets2panda/test/parser/ets/float_pont_format_3-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_4-expected.txt b/ets2panda/test/parser/ets/float_pont_format_4-expected.txt index d6d8338179..74f0a09756 100644 --- a/ets2panda/test/parser/ets/float_pont_format_4-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_5-expected.txt b/ets2panda/test/parser/ets/float_pont_format_5-expected.txt index 4913b2533c..b5eabd70cc 100644 --- a/ets2panda/test/parser/ets/float_pont_format_5-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_5-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_5.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_5.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_5.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_6-expected.txt b/ets2panda/test/parser/ets/float_pont_format_6-expected.txt index 0fafd5d120..fc847947e0 100644 --- a/ets2panda/test/parser/ets/float_pont_format_6-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_6-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_6.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_6.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_7-expected.txt b/ets2panda/test/parser/ets/float_pont_format_7-expected.txt index 99931a57f0..632e2de9ed 100644 --- a/ets2panda/test/parser/ets/float_pont_format_7-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_7-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_7.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_7.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_pont_format_8-expected.txt b/ets2panda/test/parser/ets/float_pont_format_8-expected.txt index 034dfbfa3c..a11a9162ba 100644 --- a/ets2panda/test/parser/ets/float_pont_format_8-expected.txt +++ b/ets2panda/test/parser/ets/float_pont_format_8-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_8.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_8.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_pont_format_8.ets" } } }, diff --git a/ets2panda/test/parser/ets/float_separator_1-expected.txt b/ets2panda/test/parser/ets/float_separator_1-expected.txt index f90de87c9c..81c9d0875e 100644 --- a/ets2panda/test/parser/ets/float_separator_1-expected.txt +++ b/ets2panda/test/parser/ets/float_separator_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_separator_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_separator_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_separator_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_separator_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "float_separator_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "float_separator_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/folder_import_index/index-expected.txt b/ets2panda/test/parser/ets/folder_import_index/index-expected.txt index 785feb50d8..b3fd2b5adb 100644 --- a/ets2panda/test/parser/ets/folder_import_index/index-expected.txt +++ b/ets2panda/test/parser/ets/folder_import_index/index-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, diff --git a/ets2panda/test/parser/ets/for_of-expected.txt b/ets2panda/test/parser/ets/for_of-expected.txt index 2a62e69595..f968adacc6 100644 --- a/ets2panda/test/parser/ets/for_of-expected.txt +++ b/ets2panda/test/parser/ets/for_of-expected.txt @@ -192,40 +192,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "for_of.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 25, + "program": "for_of.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "for_of.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 25, + "program": "for_of.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "for_of.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 25, + "program": "for_of.ets" } } }, @@ -233,13 +233,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "for_of.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 25, "program": "for_of.ets" } } diff --git a/ets2panda/test/parser/ets/for_with_break-expected.txt b/ets2panda/test/parser/ets/for_with_break-expected.txt index 257f20e53e..d60aa7ae34 100644 --- a/ets2panda/test/parser/ets/for_with_break-expected.txt +++ b/ets2panda/test/parser/ets/for_with_break-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "for_with_break.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "for_with_break.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "for_with_break.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "for_with_break.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "for_with_break.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "for_with_break.ets" } } }, diff --git a/ets2panda/test/parser/ets/forofUnboxing-expected.txt b/ets2panda/test/parser/ets/forofUnboxing-expected.txt index 10cc306b5c..cdbdae00b3 100644 --- a/ets2panda/test/parser/ets/forofUnboxing-expected.txt +++ b/ets2panda/test/parser/ets/forofUnboxing-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forofUnboxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forofUnboxing.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forofUnboxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forofUnboxing.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "forofUnboxing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "forofUnboxing.ets" } } }, diff --git a/ets2panda/test/parser/ets/funcParamWithOptionalParam-expected.txt b/ets2panda/test/parser/ets/funcParamWithOptionalParam-expected.txt index edab393734..674b58fdb3 100644 --- a/ets2panda/test/parser/ets/funcParamWithOptionalParam-expected.txt +++ b/ets2panda/test/parser/ets/funcParamWithOptionalParam-expected.txt @@ -347,12 +347,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" } } }, @@ -360,12 +360,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" } } }, @@ -373,12 +373,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" } } }, @@ -453,12 +453,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" } } }, @@ -466,12 +466,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" } } }, @@ -479,12 +479,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "funcParamWithOptionalParam.ets" } } }, diff --git a/ets2panda/test/parser/ets/function-expected.txt b/ets2panda/test/parser/ets/function-expected.txt index eb48d84352..47f01ee73d 100644 --- a/ets2panda/test/parser/ets/function-expected.txt +++ b/ets2panda/test/parser/ets/function-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function.ets" } } }, @@ -411,40 +411,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 34, + "column": 5, + "program": "function.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 36, + "column": 2, + "program": "function.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 34, + "column": 5, + "program": "function.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 36, + "column": 2, + "program": "function.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 34, + "column": 5, + "program": "function.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 36, + "column": 2, + "program": "function.ets" } } }, @@ -452,13 +452,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 34, + "column": 5, "program": "function.ets" }, "end": { - "line": 1, - "column": 1, + "line": 36, + "column": 2, "program": "function.ets" } } diff --git a/ets2panda/test/parser/ets/functionThrowsRethrows-expected.txt b/ets2panda/test/parser/ets/functionThrowsRethrows-expected.txt index 4d1c381ee1..b96db2bcbb 100644 --- a/ets2panda/test/parser/ets/functionThrowsRethrows-expected.txt +++ b/ets2panda/test/parser/ets/functionThrowsRethrows-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionThrowsRethrows.ets" } } }, diff --git a/ets2panda/test/parser/ets/functionTypeThrows-expected.txt b/ets2panda/test/parser/ets/functionTypeThrows-expected.txt index 072678965d..958f5cc5a8 100644 --- a/ets2panda/test/parser/ets/functionTypeThrows-expected.txt +++ b/ets2panda/test/parser/ets/functionTypeThrows-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "functionTypeThrows.ets" } } }, diff --git a/ets2panda/test/parser/ets/function_implicit_return_type5-expected.txt b/ets2panda/test/parser/ets/function_implicit_return_type5-expected.txt index 3600cede6a..b96de3632a 100644 --- a/ets2panda/test/parser/ets/function_implicit_return_type5-expected.txt +++ b/ets2panda/test/parser/ets/function_implicit_return_type5-expected.txt @@ -373,12 +373,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" } } }, @@ -386,12 +386,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" } } }, @@ -399,12 +399,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" } } }, @@ -479,12 +479,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" } } }, @@ -492,12 +492,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" } } }, @@ -505,12 +505,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type5.ets" } } }, diff --git a/ets2panda/test/parser/ets/function_implicit_return_type6-expected.txt b/ets2panda/test/parser/ets/function_implicit_return_type6-expected.txt index 4c8c6eb29b..03954a64fd 100644 --- a/ets2panda/test/parser/ets/function_implicit_return_type6-expected.txt +++ b/ets2panda/test/parser/ets/function_implicit_return_type6-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type6.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type6.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type6.ets" } } }, diff --git a/ets2panda/test/parser/ets/function_implicit_return_type8-expected.txt b/ets2panda/test/parser/ets/function_implicit_return_type8-expected.txt index dd55942add..0962ccef9c 100644 --- a/ets2panda/test/parser/ets/function_implicit_return_type8-expected.txt +++ b/ets2panda/test/parser/ets/function_implicit_return_type8-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type8.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type8.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type8.ets" } } }, diff --git a/ets2panda/test/parser/ets/function_implicit_return_type9-expected.txt b/ets2panda/test/parser/ets/function_implicit_return_type9-expected.txt index 3355f5dd6d..66d7eac058 100644 --- a/ets2panda/test/parser/ets/function_implicit_return_type9-expected.txt +++ b/ets2panda/test/parser/ets/function_implicit_return_type9-expected.txt @@ -420,12 +420,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type9.ets" } } }, @@ -433,12 +433,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type9.ets" } } }, @@ -446,12 +446,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "function_implicit_return_type9.ets" } } }, diff --git a/ets2panda/test/parser/ets/genericDefaultParam_1-expected.txt b/ets2panda/test/parser/ets/genericDefaultParam_1-expected.txt index 54083cdaef..96a72b4e64 100644 --- a/ets2panda/test/parser/ets/genericDefaultParam_1-expected.txt +++ b/ets2panda/test/parser/ets/genericDefaultParam_1-expected.txt @@ -1649,12 +1649,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" } } }, @@ -1662,12 +1662,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" } } }, @@ -1675,12 +1675,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" } } }, @@ -2870,40 +2870,40 @@ ], "loc": { "start": { - "line": 1, + "line": 20, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" }, "end": { - "line": 1, + "line": 34, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" } } }, "loc": { "start": { - "line": 1, + "line": 20, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" }, "end": { - "line": 1, + "line": 34, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" } } }, "loc": { "start": { - "line": 1, + "line": 20, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" }, "end": { - "line": 1, + "line": 34, "column": 1, - "program": null + "program": "genericDefaultParam_1.ets" } } }, @@ -2911,12 +2911,12 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 20, "column": 1, "program": "genericDefaultParam_1.ets" }, "end": { - "line": 1, + "line": 34, "column": 1, "program": "genericDefaultParam_1.ets" } diff --git a/ets2panda/test/parser/ets/genericDefaultParam_3-expected.txt b/ets2panda/test/parser/ets/genericDefaultParam_3-expected.txt index dba63f9984..e5fc0bf4fc 100644 --- a/ets2panda/test/parser/ets/genericDefaultParam_3-expected.txt +++ b/ets2panda/test/parser/ets/genericDefaultParam_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" } } }, @@ -251,40 +251,40 @@ ], "loc": { "start": { - "line": 1, + "line": 20, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 13, + "program": "genericDefaultParam_3.ets" } } }, "loc": { "start": { - "line": 1, + "line": 20, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 13, + "program": "genericDefaultParam_3.ets" } } }, "loc": { "start": { - "line": 1, + "line": 20, "column": 1, - "program": null + "program": "genericDefaultParam_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 13, + "program": "genericDefaultParam_3.ets" } } }, @@ -292,13 +292,13 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 20, "column": 1, "program": "genericDefaultParam_3.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 13, "program": "genericDefaultParam_3.ets" } } diff --git a/ets2panda/test/parser/ets/generic_function-expected.txt b/ets2panda/test/parser/ets/generic_function-expected.txt index 7259f200d0..6425534814 100644 --- a/ets2panda/test/parser/ets/generic_function-expected.txt +++ b/ets2panda/test/parser/ets/generic_function-expected.txt @@ -347,12 +347,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" } } }, @@ -360,12 +360,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" } } }, @@ -373,12 +373,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" } } }, @@ -453,12 +453,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" } } }, @@ -466,12 +466,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" } } }, @@ -479,12 +479,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_function.ets" } } }, diff --git a/ets2panda/test/parser/ets/generic_resolve-expected.txt b/ets2panda/test/parser/ets/generic_resolve-expected.txt index d3b80a2c42..9f9dad8744 100644 --- a/ets2panda/test/parser/ets/generic_resolve-expected.txt +++ b/ets2panda/test/parser/ets/generic_resolve-expected.txt @@ -1422,12 +1422,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" } } }, @@ -1435,12 +1435,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" } } }, @@ -1448,12 +1448,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" } } }, @@ -1528,12 +1528,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" } } }, @@ -1541,12 +1541,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" } } }, @@ -1554,12 +1554,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generic_resolve.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_2-expected.txt b/ets2panda/test/parser/ets/generics_2-expected.txt index 8249c4cb80..80daeae5ad 100644 --- a/ets2panda/test/parser/ets/generics_2-expected.txt +++ b/ets2panda/test/parser/ets/generics_2-expected.txt @@ -1534,12 +1534,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" } } }, @@ -1547,12 +1547,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" } } }, @@ -1560,12 +1560,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" } } }, @@ -1640,12 +1640,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" } } }, @@ -1653,12 +1653,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" } } }, @@ -1666,12 +1666,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_3-expected.txt b/ets2panda/test/parser/ets/generics_3-expected.txt index 420b5968fa..49f6186bb1 100644 --- a/ets2panda/test/parser/ets/generics_3-expected.txt +++ b/ets2panda/test/parser/ets/generics_3-expected.txt @@ -316,12 +316,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_3.ets" } } }, @@ -329,12 +329,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_3.ets" } } }, @@ -342,12 +342,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_4-expected.txt b/ets2panda/test/parser/ets/generics_4-expected.txt index be1b9816a8..130c4a1f94 100644 --- a/ets2panda/test/parser/ets/generics_4-expected.txt +++ b/ets2panda/test/parser/ets/generics_4-expected.txt @@ -348,12 +348,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_4.ets" } } }, @@ -361,12 +361,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_4.ets" } } }, @@ -374,12 +374,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_5-expected.txt b/ets2panda/test/parser/ets/generics_5-expected.txt index 246ddfa0a4..c9ec195c16 100644 --- a/ets2panda/test/parser/ets/generics_5-expected.txt +++ b/ets2panda/test/parser/ets/generics_5-expected.txt @@ -284,12 +284,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_5.ets" } } }, @@ -297,12 +297,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_5.ets" } } }, @@ -310,12 +310,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_5.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_6-expected.txt b/ets2panda/test/parser/ets/generics_6-expected.txt index 2cfd7603b0..0f2f38d503 100644 --- a/ets2panda/test/parser/ets/generics_6-expected.txt +++ b/ets2panda/test/parser/ets/generics_6-expected.txt @@ -520,12 +520,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_6.ets" } } }, @@ -533,12 +533,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_6.ets" } } }, @@ -546,12 +546,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_7-expected.txt b/ets2panda/test/parser/ets/generics_7-expected.txt index 4df7ac16fa..42af81815f 100644 --- a/ets2panda/test/parser/ets/generics_7-expected.txt +++ b/ets2panda/test/parser/ets/generics_7-expected.txt @@ -520,12 +520,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_7.ets" } } }, @@ -533,12 +533,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_7.ets" } } }, @@ -546,12 +546,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_recursive-expected.txt b/ets2panda/test/parser/ets/generics_recursive-expected.txt index d12bab3228..2be78e851b 100644 --- a/ets2panda/test/parser/ets/generics_recursive-expected.txt +++ b/ets2panda/test/parser/ets/generics_recursive-expected.txt @@ -3167,12 +3167,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" } } }, @@ -3180,12 +3180,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" } } }, @@ -3193,12 +3193,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" } } }, @@ -3273,12 +3273,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" } } }, @@ -3286,12 +3286,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" } } }, @@ -3299,12 +3299,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_recursive.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_1-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_1-expected.txt index ee6dbbddaa..71d04ce458 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_1-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_1-expected.txt @@ -395,12 +395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_1.ets" } } }, @@ -408,12 +408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_1.ets" } } }, @@ -421,12 +421,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_10-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_10-expected.txt index 4d3683d337..786a63eb29 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_10-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_10-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_10.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_10.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_10.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_11-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_11-expected.txt index 008accd3f1..f9da1689fb 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_11-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_11-expected.txt @@ -1172,12 +1172,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" } } }, @@ -1185,12 +1185,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" } } }, @@ -1198,12 +1198,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" } } }, @@ -1278,12 +1278,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" } } }, @@ -1291,12 +1291,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" } } }, @@ -1304,12 +1304,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_11.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_12-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_12-expected.txt index e939edf546..9684dc7631 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_12-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_12-expected.txt @@ -1131,12 +1131,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" } } }, @@ -1144,12 +1144,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" } } }, @@ -1157,12 +1157,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" } } }, @@ -1237,12 +1237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" } } }, @@ -1250,12 +1250,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" } } }, @@ -1263,12 +1263,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_12.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_2-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_2-expected.txt index 3e279d79a3..a0fa5c4424 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_2-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_2-expected.txt @@ -289,12 +289,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" } } }, @@ -302,12 +302,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" } } }, @@ -315,12 +315,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" } } }, @@ -395,12 +395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" } } }, @@ -408,12 +408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" } } }, @@ -421,12 +421,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_3-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_3-expected.txt index 0c8ae7c3b3..296a7f0dd7 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_3-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_4-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_4-expected.txt index ae119ef2ff..b2dec07424 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_4-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_4-expected.txt @@ -679,12 +679,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" } } }, @@ -692,12 +692,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" } } }, @@ -705,12 +705,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" } } }, @@ -785,12 +785,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" } } }, @@ -798,12 +798,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" } } }, @@ -811,12 +811,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_5-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_5-expected.txt index 01493e7a88..14f1364a62 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_5-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_5-expected.txt @@ -975,12 +975,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" } } }, @@ -988,12 +988,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" } } }, @@ -1001,12 +1001,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" } } }, @@ -1081,12 +1081,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" } } }, @@ -1094,12 +1094,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" } } }, @@ -1107,12 +1107,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_5.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_6-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_6-expected.txt index 6020eed9e9..9b38405bea 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_6-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_6-expected.txt @@ -427,12 +427,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_6.ets" } } }, @@ -440,12 +440,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_6.ets" } } }, @@ -453,12 +453,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_7-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_7-expected.txt index 2b3d80beb9..9018e47953 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_7-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_7-expected.txt @@ -395,12 +395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_7.ets" } } }, @@ -408,12 +408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_7.ets" } } }, @@ -421,12 +421,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/generics_type_param_constraint_9-expected.txt b/ets2panda/test/parser/ets/generics_type_param_constraint_9-expected.txt index 2e9f5872ee..188cabf31a 100644 --- a/ets2panda/test/parser/ets/generics_type_param_constraint_9-expected.txt +++ b/ets2panda/test/parser/ets/generics_type_param_constraint_9-expected.txt @@ -864,12 +864,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_9.ets" } } }, @@ -877,12 +877,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_9.ets" } } }, @@ -890,12 +890,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "generics_type_param_constraint_9.ets" } } }, diff --git a/ets2panda/test/parser/ets/getterOverride-expected.txt b/ets2panda/test/parser/ets/getterOverride-expected.txt index 64aef4f75f..8b5b981e90 100644 --- a/ets2panda/test/parser/ets/getterOverride-expected.txt +++ b/ets2panda/test/parser/ets/getterOverride-expected.txt @@ -670,12 +670,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" } } }, @@ -683,12 +683,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" } } }, @@ -696,12 +696,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" } } }, @@ -776,12 +776,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" } } }, @@ -789,12 +789,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" } } }, @@ -802,12 +802,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getterOverride.ets" } } }, diff --git a/ets2panda/test/parser/ets/getter_setter_access_modifiers-expected.txt b/ets2panda/test/parser/ets/getter_setter_access_modifiers-expected.txt index 25155cb553..64641f90ef 100644 --- a/ets2panda/test/parser/ets/getter_setter_access_modifiers-expected.txt +++ b/ets2panda/test/parser/ets/getter_setter_access_modifiers-expected.txt @@ -2022,12 +2022,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" } } }, @@ -2035,12 +2035,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" } } }, @@ -2048,12 +2048,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" } } }, @@ -2128,12 +2128,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" } } }, @@ -2141,12 +2141,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" } } }, @@ -2154,12 +2154,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "getter_setter_access_modifiers.ets" } } }, diff --git a/ets2panda/test/parser/ets/globalVarInLambdaInStatic-expected.txt b/ets2panda/test/parser/ets/globalVarInLambdaInStatic-expected.txt index 08a8f0e8bb..3d009e987b 100644 --- a/ets2panda/test/parser/ets/globalVarInLambdaInStatic-expected.txt +++ b/ets2panda/test/parser/ets/globalVarInLambdaInStatic-expected.txt @@ -1013,12 +1013,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" } } }, @@ -1026,12 +1026,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" } } }, @@ -1039,12 +1039,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" } } }, @@ -1119,12 +1119,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" } } }, @@ -1132,12 +1132,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" } } }, @@ -1145,12 +1145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "globalVarInLambdaInStatic.ets" } } }, diff --git a/ets2panda/test/parser/ets/global_const_vars3-expected.txt b/ets2panda/test/parser/ets/global_const_vars3-expected.txt index 0353208900..43fea067a2 100644 --- a/ets2panda/test/parser/ets/global_const_vars3-expected.txt +++ b/ets2panda/test/parser/ets/global_const_vars3-expected.txt @@ -588,12 +588,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" } } }, @@ -601,12 +601,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" } } }, @@ -614,12 +614,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" } } }, @@ -694,12 +694,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" } } }, @@ -707,12 +707,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" } } }, @@ -720,12 +720,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "global_const_vars3.ets" } } }, diff --git a/ets2panda/test/parser/ets/identifier-expected.txt b/ets2panda/test/parser/ets/identifier-expected.txt index 6769831643..a6f4417fea 100644 --- a/ets2panda/test/parser/ets/identifier-expected.txt +++ b/ets2panda/test/parser/ets/identifier-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifier.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifier.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "identifier.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "identifier.ets" } } }, @@ -377,40 +377,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "identifier.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 27, + "program": "identifier.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "identifier.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 27, + "program": "identifier.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "identifier.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 27, + "program": "identifier.ets" } } }, @@ -418,13 +418,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "identifier.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 27, "program": "identifier.ets" } } diff --git a/ets2panda/test/parser/ets/if-expected.txt b/ets2panda/test/parser/ets/if-expected.txt index 5191a792b8..f9582adc85 100644 --- a/ets2panda/test/parser/ets/if-expected.txt +++ b/ets2panda/test/parser/ets/if-expected.txt @@ -3079,12 +3079,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "if.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "if.ets" } } }, @@ -3092,12 +3092,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "if.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "if.ets" } } }, @@ -3105,12 +3105,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "if.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "if.ets" } } }, @@ -3185,12 +3185,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "if.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "if.ets" } } }, @@ -3198,12 +3198,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "if.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "if.ets" } } }, @@ -3211,12 +3211,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "if.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "if.ets" } } }, diff --git a/ets2panda/test/parser/ets/ifs-expected.txt b/ets2panda/test/parser/ets/ifs-expected.txt index 2718e28ed7..58b0d3984c 100644 --- a/ets2panda/test/parser/ets/ifs-expected.txt +++ b/ets2panda/test/parser/ets/ifs-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ifs.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_conts-expected.txt b/ets2panda/test/parser/ets/import_conts-expected.txt index 8254df01f7..baf26b45e8 100644 --- a/ets2panda/test/parser/ets/import_conts-expected.txt +++ b/ets2panda/test/parser/ets/import_conts-expected.txt @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_conts.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_conts.ets" } } }, @@ -322,12 +322,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_conts.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_conts.ets" } } }, @@ -335,12 +335,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_conts.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_conts.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_folder-expected.txt b/ets2panda/test/parser/ets/import_folder-expected.txt index 9e34c3fef4..2b3a2754d3 100644 --- a/ets2panda/test/parser/ets/import_folder-expected.txt +++ b/ets2panda/test/parser/ets/import_folder-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_folder.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_folder.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_folder.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_folder.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_folder.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_folder.ets" } } }, @@ -333,40 +333,40 @@ ], "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_folder.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 10, + "program": "import_folder.ets" } } }, "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_folder.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 10, + "program": "import_folder.ets" } } }, "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_folder.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 10, + "program": "import_folder.ets" } } }, @@ -374,13 +374,13 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 18, "column": 1, "program": "import_folder.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 10, "program": "import_folder.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/check_exported_2-expected.txt b/ets2panda/test/parser/ets/import_tests/check_exported_2-expected.txt index e102397efd..904d5fb076 100644 --- a/ets2panda/test/parser/ets/import_tests/check_exported_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/check_exported_2-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" } } }, @@ -251,12 +251,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" } } }, @@ -264,12 +264,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" } } }, @@ -277,12 +277,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/check_exported_3-expected.txt b/ets2panda/test/parser/ets/import_tests/check_exported_3-expected.txt index 2e90889a67..c1ce9f969b 100644 --- a/ets2panda/test/parser/ets/import_tests/check_exported_3-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/check_exported_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/check_exported_default_class-expected.txt b/ets2panda/test/parser/ets/import_tests/check_exported_default_class-expected.txt index 298a6f3d02..f7a571b353 100644 --- a/ets2panda/test/parser/ets/import_tests/check_exported_default_class-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/check_exported_default_class-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_default_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_default_class.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_default_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_default_class.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "check_exported_default_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "check_exported_default_class.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/default_import-expected.txt b/ets2panda/test/parser/ets/import_tests/default_import-expected.txt index b21ecc8295..fe7c3e9a0c 100644 --- a/ets2panda/test/parser/ets/import_tests/default_import-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/default_import-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_import.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_import.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_import.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/diamond/test1-expected.txt b/ets2panda/test/parser/ets/import_tests/diamond/test1-expected.txt index 310273526f..e081d86b4d 100644 --- a/ets2panda/test/parser/ets/import_tests/diamond/test1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/diamond/test1-expected.txt @@ -244,12 +244,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test1.ets" } } }, @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test1.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/diamond/test2-expected.txt b/ets2panda/test/parser/ets/import_tests/diamond/test2-expected.txt index 7addb00967..c4a28c662d 100644 --- a/ets2panda/test/parser/ets/import_tests/diamond/test2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/diamond/test2-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test2.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test2.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test2.ets" } } }, @@ -332,40 +332,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "test2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 21, + "program": "test2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "test2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 21, + "program": "test2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "test2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 21, + "program": "test2.ets" } } }, @@ -373,13 +373,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "test2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 21, "program": "test2.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/diamond/test3-expected.txt b/ets2panda/test/parser/ets/import_tests/diamond/test3-expected.txt index af733650c9..d3f7c60275 100644 --- a/ets2panda/test/parser/ets/import_tests/diamond/test3-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/diamond/test3-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test3.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test3.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test3.ets" } } }, @@ -332,40 +332,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "test3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 21, + "program": "test3.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "test3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 21, + "program": "test3.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "test3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 21, + "program": "test3.ets" } } }, @@ -373,13 +373,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "test3.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 21, "program": "test3.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/diamond/test4-expected.txt b/ets2panda/test/parser/ets/import_tests/diamond/test4-expected.txt index ae9ea1042b..4873ef0aca 100644 --- a/ets2panda/test/parser/ets/import_tests/diamond/test4-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/diamond/test4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test4.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "test4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 19, + "program": "test4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "test4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 19, + "program": "test4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "test4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 19, + "program": "test4.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "test4.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 19, "program": "test4.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/duplicated/classdef-expected.txt b/ets2panda/test/parser/ets/import_tests/duplicated/classdef-expected.txt index 45ab948105..6deca414cf 100644 --- a/ets2panda/test/parser/ets/import_tests/duplicated/classdef-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/duplicated/classdef-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "classdef.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/duplicated/extdef-expected.txt b/ets2panda/test/parser/ets/import_tests/duplicated/extdef-expected.txt index 0989c4685e..50233e3a7d 100644 --- a/ets2panda/test/parser/ets/import_tests/duplicated/extdef-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/duplicated/extdef-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" } } }, @@ -268,12 +268,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" } } }, @@ -281,12 +281,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" } } }, @@ -294,12 +294,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extdef.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/duplicated/extusedef-expected.txt b/ets2panda/test/parser/ets/import_tests/duplicated/extusedef-expected.txt index 75b4a52596..8dc2532cec 100644 --- a/ets2panda/test/parser/ets/import_tests/duplicated/extusedef-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/duplicated/extusedef-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extusedef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extusedef.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extusedef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extusedef.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "extusedef.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "extusedef.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/export_type_alias-expected.txt b/ets2panda/test/parser/ets/import_tests/export_type_alias-expected.txt index 06d45cc4bd..1434bcf65d 100644 --- a/ets2panda/test/parser/ets/import_tests/export_type_alias-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/export_type_alias-expected.txt @@ -361,12 +361,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" } } }, @@ -374,12 +374,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" } } }, @@ -387,12 +387,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" } } }, @@ -467,12 +467,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" } } }, @@ -480,12 +480,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" } } }, @@ -493,12 +493,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_type_alias.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/folderWithoutIndexOrPackage/separate_module-expected.txt b/ets2panda/test/parser/ets/import_tests/folderWithoutIndexOrPackage/separate_module-expected.txt index fbcfef566b..55bfea0bcf 100644 --- a/ets2panda/test/parser/ets/import_tests/folderWithoutIndexOrPackage/separate_module-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/folderWithoutIndexOrPackage/separate_module-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "separate_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "separate_module.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 24, + "program": "separate_module.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 24, + "program": "separate_module.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "separate_module.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 24, + "program": "separate_module.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "separate_module.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 24, "program": "separate_module.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_alias/export-expected.txt b/ets2panda/test/parser/ets/import_tests/import_alias/export-expected.txt index 26bd73fa07..0ca3ab585f 100644 --- a/ets2panda/test/parser/ets/import_tests/import_alias/export-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_alias/export-expected.txt @@ -602,12 +602,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -615,12 +615,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -628,12 +628,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -835,40 +835,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 28, + "column": 5, + "program": "export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 30, + "column": 21, + "program": "export.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 28, + "column": 5, + "program": "export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 30, + "column": 21, + "program": "export.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 28, + "column": 5, + "program": "export.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 30, + "column": 21, + "program": "export.ets" } } }, @@ -876,13 +876,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 28, + "column": 5, "program": "export.ets" }, "end": { - "line": 1, - "column": 1, + "line": 30, + "column": 21, "program": "export.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_alias/import_alias_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_alias/import_alias_1-expected.txt index 4b4b585589..80b3629c7c 100644 --- a/ets2panda/test/parser/ets/import_tests/import_alias/import_alias_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_alias/import_alias_1-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_1.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_1.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_1-expected.txt index 48779566b1..0ac5d41a7a 100644 --- a/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_1-expected.txt @@ -227,12 +227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_1.ets" } } }, @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_1.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_2-expected.txt b/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_2-expected.txt index bbfd91b505..30b22642eb 100644 --- a/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_2-expected.txt @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_2.ets" } } }, @@ -322,12 +322,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_2.ets" } } }, @@ -335,12 +335,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_3-expected.txt b/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_3-expected.txt index 39f464276c..3327cfbf56 100644 --- a/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_3-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_alias_and_without_alias_3-expected.txt @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_3.ets" } } }, @@ -322,12 +322,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_3.ets" } } }, @@ -335,12 +335,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_alias_and_without_alias_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_all-expected.txt b/ets2panda/test/parser/ets/import_tests/import_all-expected.txt index be878c9f40..0512196c66 100755 --- a/ets2panda/test/parser/ets/import_tests/import_all-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_all-expected.txt @@ -210,12 +210,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all.ets" } } }, @@ -223,12 +223,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all.ets" } } }, @@ -236,12 +236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all.ets" } } }, @@ -784,40 +784,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_all.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 52, + "program": "import_all.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_all.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 52, + "program": "import_all.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_all.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 52, + "program": "import_all.ets" } } }, @@ -825,13 +825,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "import_all.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 52, "program": "import_all.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_all_3-expected.txt b/ets2panda/test/parser/ets/import_tests/import_all_3-expected.txt index 54bfc27c40..494c9892e0 100644 --- a/ets2panda/test/parser/ets/import_tests/import_all_3-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_all_3-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_3.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_3.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_all_alias_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_all_alias_1-expected.txt index b048ff97aa..bbac32e282 100644 --- a/ets2panda/test/parser/ets/import_tests/import_all_alias_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_all_alias_1-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_alias_1.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_alias_1.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_alias_1.ets" } } }, @@ -586,40 +586,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_all_alias_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 55, + "program": "import_all_alias_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_all_alias_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 55, + "program": "import_all_alias_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_all_alias_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 55, + "program": "import_all_alias_1.ets" } } }, @@ -627,13 +627,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "import_all_alias_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 55, "program": "import_all_alias_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_all_type_alias-expected.txt b/ets2panda/test/parser/ets/import_tests/import_all_type_alias-expected.txt index 68fb4cac40..24b5da6c5c 100644 --- a/ets2panda/test/parser/ets/import_tests/import_all_type_alias-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_all_type_alias-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_type_alias.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_type_alias.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_all_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_all_type_alias.ets" } } }, @@ -393,40 +393,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "import_all_type_alias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 37, + "program": "import_all_type_alias.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "import_all_type_alias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 37, + "program": "import_all_type_alias.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 5, + "program": "import_all_type_alias.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 37, + "program": "import_all_type_alias.ets" } } }, @@ -434,13 +434,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 22, + "column": 5, "program": "import_all_type_alias.ets" }, "end": { - "line": 1, - "column": 1, + "line": 22, + "column": 37, "program": "import_all_type_alias.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt b/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt index 813b3fb1ba..9eac1209f5 100644 --- a/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_diff_paths-expected.txt @@ -244,12 +244,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_diff_paths.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_diff_paths.ets" } } }, @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_diff_paths.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_diff_paths.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_diff_paths.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_diff_paths.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_extension/import_extension-expected.txt b/ets2panda/test/parser/ets/import_tests/import_extension/import_extension-expected.txt index 971b99fd70..a49ac592e7 100644 --- a/ets2panda/test/parser/ets/import_tests/import_extension/import_extension-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_extension/import_extension-expected.txt @@ -244,12 +244,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension.ets" } } }, @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_1-expected.txt index 4dbe29d09c..9700014139 100644 --- a/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension_1.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "import_extension_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 21, + "program": "import_extension_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "import_extension_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 21, + "program": "import_extension_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "import_extension_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 21, + "program": "import_extension_1.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "import_extension_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 21, "program": "import_extension_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_2-expected.txt b/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_2-expected.txt index a6b21c9fce..78421e2796 100644 --- a/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_extension/import_extension_2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension_2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension_2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_extension_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_extension_2.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "import_extension_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 21, + "program": "import_extension_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "import_extension_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 21, + "program": "import_extension_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "import_extension_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 21, + "program": "import_extension_2.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "import_extension_2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 21, "program": "import_extension_2.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_function_overload-expected.txt b/ets2panda/test/parser/ets/import_tests/import_function_overload-expected.txt index 43bc9c4d8f..0cf4c3ee71 100644 --- a/ets2panda/test/parser/ets/import_tests/import_function_overload-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_function_overload-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_function_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_function_overload.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_function_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_function_overload.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_function_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_function_overload.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_interface_test-expected.txt b/ets2panda/test/parser/ets/import_tests/import_interface_test-expected.txt index 5bc0500823..9f694dad62 100644 --- a/ets2panda/test/parser/ets/import_tests/import_interface_test-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_interface_test-expected.txt @@ -615,12 +615,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test.ets" } } }, @@ -628,12 +628,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test.ets" } } }, @@ -641,12 +641,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_interface_test_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_interface_test_1-expected.txt index 579475c53e..cad723ef3b 100644 --- a/ets2panda/test/parser/ets/import_tests/import_interface_test_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_interface_test_1-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_interface_test_2-expected.txt b/ets2panda/test/parser/ets/import_tests/import_interface_test_2-expected.txt index 451905f99c..593631d9ca 100644 --- a/ets2panda/test/parser/ets/import_tests/import_interface_test_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_interface_test_2-expected.txt @@ -533,12 +533,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" } } }, @@ -546,12 +546,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" } } }, @@ -559,12 +559,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" } } }, @@ -639,12 +639,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" } } }, @@ -652,12 +652,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" } } }, @@ -665,12 +665,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_interface_test_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_max_as_alias-expected.txt b/ets2panda/test/parser/ets/import_tests/import_max_as_alias-expected.txt index a22980af7b..a5502177bd 100644 --- a/ets2panda/test/parser/ets/import_tests/import_max_as_alias-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_max_as_alias-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_max_as_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_max_as_alias.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_max_as_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_max_as_alias.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_max_as_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_max_as_alias.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/import_name_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_name_1-expected.txt index 3499dcfc7f..441a88ed80 100755 --- a/ets2panda/test/parser/ets/import_tests/import_name_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_name_1-expected.txt @@ -260,12 +260,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_name_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_name_1.ets" } } }, @@ -273,12 +273,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_name_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_name_1.ets" } } }, @@ -286,12 +286,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_name_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_name_1.ets" } } }, @@ -565,40 +565,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_name_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 45, + "program": "import_name_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_name_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 45, + "program": "import_name_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_name_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 45, + "program": "import_name_1.ets" } } }, @@ -606,13 +606,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "import_name_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 45, "program": "import_name_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_name_alias_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_name_alias_1-expected.txt index 699ce235c2..3f0ce318a4 100755 --- a/ets2panda/test/parser/ets/import_tests/import_name_alias_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_name_alias_1-expected.txt @@ -260,12 +260,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_name_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_name_alias_1.ets" } } }, @@ -273,12 +273,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_name_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_name_alias_1.ets" } } }, @@ -286,12 +286,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_name_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_name_alias_1.ets" } } }, @@ -565,40 +565,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_name_alias_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 45, + "program": "import_name_alias_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_name_alias_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 45, + "program": "import_name_alias_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_name_alias_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 45, + "program": "import_name_alias_1.ets" } } }, @@ -606,13 +606,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "import_name_alias_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 45, "program": "import_name_alias_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_1-expected.txt index 2e79b56dc3..b8c92a8154 100644 --- a/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_1-expected.txt @@ -445,12 +445,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "imported_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "imported_module_1.ets" } } }, @@ -458,12 +458,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "imported_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "imported_module_1.ets" } } }, @@ -471,12 +471,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "imported_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "imported_module_1.ets" } } }, @@ -614,40 +614,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "imported_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 22, + "program": "imported_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "imported_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 22, + "program": "imported_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "imported_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 22, + "program": "imported_module_1.ets" } } }, @@ -655,13 +655,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "imported_module_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 22, "program": "imported_module_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_2-expected.txt b/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_2-expected.txt index c73c634d4e..ec74e48848 100644 --- a/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_name_conflicts/imported_module_2-expected.txt @@ -445,12 +445,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "imported_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "imported_module_2.ets" } } }, @@ -458,12 +458,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "imported_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "imported_module_2.ets" } } }, @@ -471,12 +471,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "imported_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "imported_module_2.ets" } } }, @@ -614,40 +614,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "imported_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 22, + "program": "imported_module_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "imported_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 22, + "program": "imported_module_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "imported_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 22, + "program": "imported_module_2.ets" } } }, @@ -655,13 +655,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "imported_module_2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 22, "program": "imported_module_2.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_relative_path-expected.txt b/ets2panda/test/parser/ets/import_tests/import_relative_path-expected.txt index 9b428c9359..59fab91e68 100755 --- a/ets2panda/test/parser/ets/import_tests/import_relative_path-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_relative_path-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_relative_path.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_relative_path.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_relative_path.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_relative_path.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_relative_path.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_relative_path.ets" } } }, @@ -586,40 +586,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_relative_path.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 53, + "program": "import_relative_path.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_relative_path.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 53, + "program": "import_relative_path.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "import_relative_path.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 53, + "program": "import_relative_path.ets" } } }, @@ -627,13 +627,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "import_relative_path.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 53, "program": "import_relative_path.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_1-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_1-expected.txt index edb6fdc92f..09a851a8c5 100755 --- a/ets2panda/test/parser/ets/import_tests/import_several_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_1-expected.txt @@ -326,12 +326,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_1.ets" } } }, @@ -339,12 +339,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_1.ets" } } }, @@ -352,12 +352,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_1.ets" } } }, @@ -631,40 +631,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "import_several_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 45, + "program": "import_several_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "import_several_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 45, + "program": "import_several_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "import_several_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 45, + "program": "import_several_1.ets" } } }, @@ -672,13 +672,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 20, + "column": 5, "program": "import_several_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 45, "program": "import_several_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_2-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_2-expected.txt index 01ca05519b..2019883103 100755 --- a/ets2panda/test/parser/ets/import_tests/import_several_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_2-expected.txt @@ -211,12 +211,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_2.ets" } } }, @@ -224,12 +224,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_2.ets" } } }, @@ -237,12 +237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_2.ets" } } }, @@ -415,40 +415,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 18, + "program": "import_several_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 18, + "program": "import_several_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 18, + "program": "import_several_2.ets" } } }, @@ -456,13 +456,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "import_several_2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 18, "program": "import_several_2.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_3-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_3-expected.txt index c3b5aca811..2314d13920 100755 --- a/ets2panda/test/parser/ets/import_tests/import_several_3-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_3-expected.txt @@ -227,12 +227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_3.ets" } } }, @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_3.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_3.ets" } } }, @@ -600,40 +600,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 49, + "program": "import_several_3.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 49, + "program": "import_several_3.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_3.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 49, + "program": "import_several_3.ets" } } }, @@ -641,13 +641,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "import_several_3.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 49, "program": "import_several_3.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_4-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_4-expected.txt index e976815b59..e85388d010 100644 --- a/ets2panda/test/parser/ets/import_tests/import_several_4-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_4-expected.txt @@ -227,12 +227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_4.ets" } } }, @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_4.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_4.ets" } } }, @@ -634,40 +634,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 55, + "program": "import_several_4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 55, + "program": "import_several_4.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_4.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 55, + "program": "import_several_4.ets" } } }, @@ -675,13 +675,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "import_several_4.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 55, "program": "import_several_4.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_5-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_5-expected.txt index 46b8037c4a..8e12cf3378 100755 --- a/ets2panda/test/parser/ets/import_tests/import_several_5-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_5-expected.txt @@ -227,12 +227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_5.ets" } } }, @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_5.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_5.ets" } } }, @@ -600,40 +600,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 49, + "program": "import_several_5.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 49, + "program": "import_several_5.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_5.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 49, + "program": "import_several_5.ets" } } }, @@ -641,13 +641,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "import_several_5.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 49, "program": "import_several_5.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_6-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_6-expected.txt index 416b7f399c..d675fc9526 100644 --- a/ets2panda/test/parser/ets/import_tests/import_several_6-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_6-expected.txt @@ -227,12 +227,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_6.ets" } } }, @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_6.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_6.ets" } } }, @@ -634,40 +634,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 55, + "program": "import_several_6.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 55, + "program": "import_several_6.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "import_several_6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 55, + "program": "import_several_6.ets" } } }, @@ -675,13 +675,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "import_several_6.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 55, "program": "import_several_6.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_several_7-expected.txt b/ets2panda/test/parser/ets/import_tests/import_several_7-expected.txt index 1a2800e166..473fb64084 100755 --- a/ets2panda/test/parser/ets/import_tests/import_several_7-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_several_7-expected.txt @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_7.ets" } } }, @@ -322,12 +322,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_7.ets" } } }, @@ -335,12 +335,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_several_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_several_7.ets" } } }, @@ -614,40 +614,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "import_several_7.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 45, + "program": "import_several_7.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "import_several_7.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 45, + "program": "import_several_7.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "import_several_7.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 45, + "program": "import_several_7.ets" } } }, @@ -655,13 +655,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 20, + "column": 5, "program": "import_several_7.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 45, "program": "import_several_7.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/import_ts_file-expected.txt b/ets2panda/test/parser/ets/import_tests/import_ts_file-expected.txt index 3904e7e7ee..5b900073a4 100644 --- a/ets2panda/test/parser/ets/import_tests/import_ts_file-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/import_ts_file-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_ts_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_ts_file.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_ts_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_ts_file.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_ts_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_ts_file.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/internals-expected.txt b/ets2panda/test/parser/ets/import_tests/internals-expected.txt index 4a28ca1e14..66ac046cdc 100644 --- a/ets2panda/test/parser/ets/import_tests/internals-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/internals-expected.txt @@ -596,12 +596,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" } } }, @@ -609,12 +609,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" } } }, @@ -622,12 +622,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" } } }, @@ -702,12 +702,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" } } }, @@ -715,12 +715,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" } } }, @@ -728,12 +728,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internals.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/class_default_module-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/class_default_module-expected.txt index ea653065a6..b602ac88fe 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/class_default_module-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/class_default_module-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "class_default_module.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/default_export-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/default_export-expected.txt index a14dec67cf..74fdb5881a 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/default_export-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/default_export-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "default_export.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/missing_default_export-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/missing_default_export-expected.txt index 8ea40b2a5b..b9a936d13d 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/missing_default_export-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/missing_default_export-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "missing_default_export.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/module1/src/re_export_file-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/module1/src/re_export_file-expected.txt index 2f47549c03..550bcbd7dc 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/module1/src/re_export_file-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/module1/src/re_export_file-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/module2/src/import_file-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/module2/src/import_file-expected.txt index 35f9aeb745..b421f27ae2 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/module2/src/import_file-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/module2/src/import_file-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" } } }, @@ -268,12 +268,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" } } }, @@ -281,12 +281,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" } } }, @@ -294,12 +294,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_file.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/module2/src/re_export_file_2-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/module2/src/re_export_file_2-expected.txt index 3c5cf52b91..66f9f0467c 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/module2/src/re_export_file_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/module2/src/re_export_file_2-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_file_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt index 00ac903d15..607628cb22 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/test_lib1-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt b/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt index c9903696aa..82ef58e5f9 100644 --- a/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/modules/test_lib2-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" } } }, @@ -268,12 +268,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" } } }, @@ -281,12 +281,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" } } }, @@ -294,12 +294,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_lib2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import1/import1-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import1/import1-expected.txt index f977566c95..204f21af2b 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import1/import1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import1/import1-expected.txt @@ -208,12 +208,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import1.ets" } } }, @@ -221,12 +221,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import1.ets" } } }, @@ -234,12 +234,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import2/import2-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import2/import2-expected.txt index a62db9b7c2..2360ded76c 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import2/import2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/aliasWithoutAlias/import2/import2-expected.txt @@ -208,12 +208,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import2.ets" } } }, @@ -221,12 +221,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import2.ets" } } }, @@ -234,12 +234,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/import_package_with_alias-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/import_package_with_alias-expected.txt index 5ddf6d66a2..02c7f65e52 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/import_package_with_alias-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/import_package_with_alias-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_package_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_package_with_alias.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_package_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_package_with_alias.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_package_with_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_package_with_alias.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/package/package_module-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/package/package_module-expected.txt index 75cec07cb7..17f316a00e 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/package/package_module-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/import_package_with_alias/package/package_module-expected.txt @@ -175,40 +175,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "package_module.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 19, + "program": "package_module.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "package_module.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 19, + "program": "package_module.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "package_module.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 19, + "program": "package_module.ets" } } }, @@ -216,13 +216,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 12, "program": "package_module.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 19, "program": "package_module.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/packages/package_module_1-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/package_module_1-expected.txt index f72675996e..8e4ded4ec9 100755 --- a/ets2panda/test/parser/ets/import_tests/packages/package_module_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/package_module_1-expected.txt @@ -144,12 +144,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, @@ -157,12 +157,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, @@ -170,12 +170,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/package_module_2-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/package_module_2-expected.txt index c746d9151e..b9265122a0 100755 --- a/ets2panda/test/parser/ets/import_tests/packages/package_module_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/package_module_2-expected.txt @@ -144,12 +144,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" } } }, @@ -157,12 +157,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" } } }, @@ -170,12 +170,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/subpackage-1/package_module_1-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/subpackage-1/package_module_1-expected.txt index e25f40ef08..5e0a7c449a 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/subpackage-1/package_module_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/subpackage-1/package_module_1-expected.txt @@ -239,40 +239,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 19, + "program": "package_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 19, + "program": "package_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 19, + "program": "package_module_1.ets" } } }, @@ -280,13 +280,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 19, "program": "package_module_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/packages/subpackage-2/package_module_1-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/subpackage-2/package_module_1-expected.txt index 36d18749fb..5b43722f62 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/subpackage-2/package_module_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/subpackage-2/package_module_1-expected.txt @@ -239,40 +239,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 19, + "program": "package_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 19, + "program": "package_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 19, + "program": "package_module_1.ets" } } }, @@ -280,13 +280,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "package_module_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 19, "program": "package_module_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/packages/subpackage/package_module_1-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/subpackage/package_module_1-expected.txt index 2388032930..3f008d9aa2 100644 --- a/ets2panda/test/parser/ets/import_tests/packages/subpackage/package_module_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/subpackage/package_module_1-expected.txt @@ -176,12 +176,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, @@ -189,12 +189,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, @@ -202,12 +202,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "package_module_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_1-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_1-expected.txt index f1c13672b8..b19bfadc56 100755 --- a/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_1-expected.txt @@ -303,40 +303,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "subpackage_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 37, + "program": "subpackage_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "subpackage_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 37, + "program": "subpackage_module_1.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "subpackage_module_1.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 37, + "program": "subpackage_module_1.ets" } } }, @@ -344,13 +344,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 12, "program": "subpackage_module_1.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 37, "program": "subpackage_module_1.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_2-expected.txt b/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_2-expected.txt index 7630965a4f..9f29a276ab 100755 --- a/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/packages/var-duplication/subpackage_module_2-expected.txt @@ -303,40 +303,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "subpackage_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 37, + "program": "subpackage_module_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "subpackage_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 37, + "program": "subpackage_module_2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 12, + "program": "subpackage_module_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 37, + "program": "subpackage_module_2.ets" } } }, @@ -344,13 +344,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 12, "program": "subpackage_module_2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 37, "program": "subpackage_module_2.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/relative_import/Line-expected.txt b/ets2panda/test/parser/ets/import_tests/relative_import/Line-expected.txt index c0ef3b9777..19d6041d32 100644 --- a/ets2panda/test/parser/ets/import_tests/relative_import/Line-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/relative_import/Line-expected.txt @@ -846,12 +846,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" } } }, @@ -859,12 +859,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" } } }, @@ -872,12 +872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" } } }, @@ -952,12 +952,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" } } }, @@ -965,12 +965,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" } } }, @@ -978,12 +978,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Line.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/relative_import/Point-expected.txt b/ets2panda/test/parser/ets/import_tests/relative_import/Point-expected.txt index 32b77957aa..43a3e62caa 100644 --- a/ets2panda/test/parser/ets/import_tests/relative_import/Point-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/relative_import/Point-expected.txt @@ -1047,12 +1047,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" } } }, @@ -1060,12 +1060,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" } } }, @@ -1073,12 +1073,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" } } }, @@ -1153,12 +1153,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" } } }, @@ -1166,12 +1166,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" } } }, @@ -1179,12 +1179,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "Point.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/relative_import/alias1-expected.txt b/ets2panda/test/parser/ets/import_tests/relative_import/alias1-expected.txt index 6d280e0677..fac134a05d 100644 --- a/ets2panda/test/parser/ets/import_tests/relative_import/alias1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/relative_import/alias1-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "alias1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "alias1.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "alias1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "alias1.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "alias1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "alias1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/relative_import/alias2-expected.txt b/ets2panda/test/parser/ets/import_tests/relative_import/alias2-expected.txt index 932b2116bf..f4b19a9cc3 100644 --- a/ets2panda/test/parser/ets/import_tests/relative_import/alias2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/relative_import/alias2-expected.txt @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "alias2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "alias2.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "alias2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "alias2.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "alias2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "alias2.ets" } } }, @@ -510,40 +510,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "alias2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 19, + "program": "alias2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "alias2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 19, + "program": "alias2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "alias2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 19, + "program": "alias2.ets" } } }, @@ -551,13 +551,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "alias2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 19, "program": "alias2.ets" } } diff --git a/ets2panda/test/parser/ets/import_tests/repeat-expected.txt b/ets2panda/test/parser/ets/import_tests/repeat-expected.txt index e16b9ca6c1..222c2edcea 100644 --- a/ets2panda/test/parser/ets/import_tests/repeat-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/repeat-expected.txt @@ -602,12 +602,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" } } }, @@ -615,12 +615,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" } } }, @@ -628,12 +628,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" } } }, @@ -708,12 +708,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" } } }, @@ -721,12 +721,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" } } }, @@ -734,12 +734,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "repeat.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder1/file1-expected.txt b/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder1/file1-expected.txt index edfa30e973..5e37cd77ff 100644 --- a/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder1/file1-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder1/file1-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" } } }, @@ -268,12 +268,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" } } }, @@ -281,12 +281,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" } } }, @@ -294,12 +294,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file1.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder2/file2-expected.txt b/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder2/file2-expected.txt index ae41b07fae..f062113c00 100644 --- a/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder2/file2-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder2/file2-expected.txt @@ -317,12 +317,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" } } }, @@ -330,12 +330,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" } } }, @@ -343,12 +343,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" } } }, @@ -423,12 +423,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" } } }, @@ -436,12 +436,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" } } }, @@ -449,12 +449,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file2.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder3/file3-expected.txt b/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder3/file3-expected.txt index 26be6a1da2..2028cb3692 100644 --- a/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder3/file3-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/subsequent_relative_imports/folder3/file3-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "file3.ets" } } }, diff --git a/ets2panda/test/parser/ets/import_tests/type/type-expected.txt b/ets2panda/test/parser/ets/import_tests/type/type-expected.txt index fa52821c44..0bf85f15bd 100644 --- a/ets2panda/test/parser/ets/import_tests/type/type-expected.txt +++ b/ets2panda/test/parser/ets/import_tests/type/type-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type.ets" } } }, diff --git a/ets2panda/test/parser/ets/index_expressions-expected.txt b/ets2panda/test/parser/ets/index_expressions-expected.txt index 263d1ae04a..4fbdc5871f 100644 --- a/ets2panda/test/parser/ets/index_expressions-expected.txt +++ b/ets2panda/test/parser/ets/index_expressions-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index_expressions.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index_expressions.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index_expressions.ets" } } }, @@ -609,40 +609,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "index_expressions.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 16, + "program": "index_expressions.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "index_expressions.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 16, + "program": "index_expressions.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "index_expressions.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 16, + "program": "index_expressions.ets" } } }, @@ -650,13 +650,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "index_expressions.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 16, "program": "index_expressions.ets" } } diff --git a/ets2panda/test/parser/ets/infer_overriding_method_return_type-expected.txt b/ets2panda/test/parser/ets/infer_overriding_method_return_type-expected.txt index 852c67f26d..ca446caa96 100644 --- a/ets2panda/test/parser/ets/infer_overriding_method_return_type-expected.txt +++ b/ets2panda/test/parser/ets/infer_overriding_method_return_type-expected.txt @@ -711,12 +711,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" } } }, @@ -724,12 +724,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" } } }, @@ -737,12 +737,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" } } }, @@ -817,12 +817,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" } } }, @@ -830,12 +830,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" } } }, @@ -843,12 +843,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "infer_overriding_method_return_type.ets" } } }, diff --git a/ets2panda/test/parser/ets/inferingEntryPointReturn-expected.txt b/ets2panda/test/parser/ets/inferingEntryPointReturn-expected.txt index 85778e5450..96fb840b5b 100644 --- a/ets2panda/test/parser/ets/inferingEntryPointReturn-expected.txt +++ b/ets2panda/test/parser/ets/inferingEntryPointReturn-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inferingEntryPointReturn.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inferingEntryPointReturn.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inferingEntryPointReturn.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inferingEntryPointReturn.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inferingEntryPointReturn.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inferingEntryPointReturn.ets" } } }, diff --git a/ets2panda/test/parser/ets/inheritance-expected.txt b/ets2panda/test/parser/ets/inheritance-expected.txt index b90a53a851..69cb334eff 100644 --- a/ets2panda/test/parser/ets/inheritance-expected.txt +++ b/ets2panda/test/parser/ets/inheritance-expected.txt @@ -1325,12 +1325,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" } } }, @@ -1338,12 +1338,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" } } }, @@ -1351,12 +1351,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" } } }, @@ -1431,12 +1431,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" } } }, @@ -1444,12 +1444,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" } } }, @@ -1457,12 +1457,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance.ets" } } }, diff --git a/ets2panda/test/parser/ets/inheritance2-expected.txt b/ets2panda/test/parser/ets/inheritance2-expected.txt index be20d9b53d..4c8c56e2b4 100644 --- a/ets2panda/test/parser/ets/inheritance2-expected.txt +++ b/ets2panda/test/parser/ets/inheritance2-expected.txt @@ -838,12 +838,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance2.ets" } } }, @@ -851,12 +851,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance2.ets" } } }, @@ -864,12 +864,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "inheritance2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "inheritance2.ets" } } }, diff --git a/ets2panda/test/parser/ets/instanceof-expected.txt b/ets2panda/test/parser/ets/instanceof-expected.txt index 0f721d5309..965bcf0e21 100644 --- a/ets2panda/test/parser/ets/instanceof-expected.txt +++ b/ets2panda/test/parser/ets/instanceof-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "instanceof.ets" } } }, diff --git a/ets2panda/test/parser/ets/interfaceMethodWithOptional-expected.txt b/ets2panda/test/parser/ets/interfaceMethodWithOptional-expected.txt index 2f5f153e60..4959556daf 100644 --- a/ets2panda/test/parser/ets/interfaceMethodWithOptional-expected.txt +++ b/ets2panda/test/parser/ets/interfaceMethodWithOptional-expected.txt @@ -468,12 +468,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" } } }, @@ -481,12 +481,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" } } }, @@ -494,12 +494,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" } } }, @@ -574,12 +574,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" } } }, @@ -587,12 +587,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" } } }, @@ -600,12 +600,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaceMethodWithOptional.ets" } } }, diff --git a/ets2panda/test/parser/ets/interface_abstract_noreturn_function-expected.txt b/ets2panda/test/parser/ets/interface_abstract_noreturn_function-expected.txt index df6360ab42..5b059df7c8 100644 --- a/ets2panda/test/parser/ets/interface_abstract_noreturn_function-expected.txt +++ b/ets2panda/test/parser/ets/interface_abstract_noreturn_function-expected.txt @@ -220,12 +220,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" } } }, @@ -233,12 +233,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" } } }, @@ -246,12 +246,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" } } }, @@ -326,12 +326,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" } } }, @@ -339,12 +339,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" } } }, @@ -352,12 +352,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_abstract_noreturn_function.ets" } } }, diff --git a/ets2panda/test/parser/ets/interface_method_default_body-expected.txt b/ets2panda/test/parser/ets/interface_method_default_body-expected.txt index dc4d7d30ae..e3d50c7e22 100644 --- a/ets2panda/test/parser/ets/interface_method_default_body-expected.txt +++ b/ets2panda/test/parser/ets/interface_method_default_body-expected.txt @@ -913,12 +913,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_method_default_body.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_method_default_body.ets" } } }, @@ -926,12 +926,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_method_default_body.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_method_default_body.ets" } } }, @@ -939,12 +939,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interface_method_default_body.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interface_method_default_body.ets" } } }, diff --git a/ets2panda/test/parser/ets/interfaces-expected.txt b/ets2panda/test/parser/ets/interfaces-expected.txt index 020f98c54c..9ca2a044c0 100644 --- a/ets2panda/test/parser/ets/interfaces-expected.txt +++ b/ets2panda/test/parser/ets/interfaces-expected.txt @@ -1289,12 +1289,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" } } }, @@ -1302,12 +1302,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" } } }, @@ -1315,12 +1315,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" } } }, @@ -1395,12 +1395,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" } } }, @@ -1408,12 +1408,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" } } }, @@ -1421,12 +1421,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "interfaces.ets" } } }, diff --git a/ets2panda/test/parser/ets/internalParsing-expected.txt b/ets2panda/test/parser/ets/internalParsing-expected.txt index a5ed8a2713..696c137336 100644 --- a/ets2panda/test/parser/ets/internalParsing-expected.txt +++ b/ets2panda/test/parser/ets/internalParsing-expected.txt @@ -757,12 +757,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internalParsing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internalParsing.ets" } } }, @@ -770,12 +770,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internalParsing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internalParsing.ets" } } }, @@ -783,12 +783,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internalParsing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internalParsing.ets" } } }, diff --git a/ets2panda/test/parser/ets/internalProtectedParsing-expected.txt b/ets2panda/test/parser/ets/internalProtectedParsing-expected.txt index d1e05bda1b..30c57b773b 100644 --- a/ets2panda/test/parser/ets/internalProtectedParsing-expected.txt +++ b/ets2panda/test/parser/ets/internalProtectedParsing-expected.txt @@ -994,12 +994,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internalProtectedParsing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internalProtectedParsing.ets" } } }, @@ -1007,12 +1007,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internalProtectedParsing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internalProtectedParsing.ets" } } }, @@ -1020,12 +1020,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "internalProtectedParsing.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "internalProtectedParsing.ets" } } }, diff --git a/ets2panda/test/parser/ets/labeledDoWhileStatement-expected.txt b/ets2panda/test/parser/ets/labeledDoWhileStatement-expected.txt index 5773b160e0..b9996b3d47 100644 --- a/ets2panda/test/parser/ets/labeledDoWhileStatement-expected.txt +++ b/ets2panda/test/parser/ets/labeledDoWhileStatement-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledDoWhileStatement.ets" } } }, diff --git a/ets2panda/test/parser/ets/labeledForStatement-expected.txt b/ets2panda/test/parser/ets/labeledForStatement-expected.txt index 440198edf0..efcc9ab144 100644 --- a/ets2panda/test/parser/ets/labeledForStatement-expected.txt +++ b/ets2panda/test/parser/ets/labeledForStatement-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledForStatement.ets" } } }, diff --git a/ets2panda/test/parser/ets/labeledSwitchStatement-expected.txt b/ets2panda/test/parser/ets/labeledSwitchStatement-expected.txt index 4b46c8ed84..efb4dff00a 100644 --- a/ets2panda/test/parser/ets/labeledSwitchStatement-expected.txt +++ b/ets2panda/test/parser/ets/labeledSwitchStatement-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledSwitchStatement.ets" } } }, diff --git a/ets2panda/test/parser/ets/labeledWhileStatement-expected.txt b/ets2panda/test/parser/ets/labeledWhileStatement-expected.txt index cefec5d022..60ace5f7ef 100644 --- a/ets2panda/test/parser/ets/labeledWhileStatement-expected.txt +++ b/ets2panda/test/parser/ets/labeledWhileStatement-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "labeledWhileStatement.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-expected.txt b/ets2panda/test/parser/ets/lambda-expected.txt index a0c5ccf1d3..8c34609e1d 100644 --- a/ets2panda/test/parser/ets/lambda-expected.txt +++ b/ets2panda/test/parser/ets/lambda-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-lambda-expected.txt b/ets2panda/test/parser/ets/lambda-lambda-expected.txt index 6490826b5d..d52afdced4 100644 --- a/ets2panda/test/parser/ets/lambda-lambda-expected.txt +++ b/ets2panda/test/parser/ets/lambda-lambda-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-lambda.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-lambda.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-lambda.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-lambda.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-type-inference-alias-expected.txt b/ets2panda/test/parser/ets/lambda-type-inference-alias-expected.txt index 6b44d7a554..57d9f461f6 100644 --- a/ets2panda/test/parser/ets/lambda-type-inference-alias-expected.txt +++ b/ets2panda/test/parser/ets/lambda-type-inference-alias-expected.txt @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-alias.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-alias.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-alias.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-type-inference-arg-no-type-expected.txt b/ets2panda/test/parser/ets/lambda-type-inference-arg-no-type-expected.txt index 150923b4a7..9bd55797c7 100644 --- a/ets2panda/test/parser/ets/lambda-type-inference-arg-no-type-expected.txt +++ b/ets2panda/test/parser/ets/lambda-type-inference-arg-no-type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-arg-no-type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-arg-no-type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-arg-no-type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-arg-no-type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-arg-no-type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-arg-no-type.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-type-inference-expected.txt b/ets2panda/test/parser/ets/lambda-type-inference-expected.txt index b8e4591d4d..d25ca49fb4 100644 --- a/ets2panda/test/parser/ets/lambda-type-inference-expected.txt +++ b/ets2panda/test/parser/ets/lambda-type-inference-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-type-inference-no-ret-type-expected.txt b/ets2panda/test/parser/ets/lambda-type-inference-no-ret-type-expected.txt index 43937f2c21..5c5a6f6e0d 100644 --- a/ets2panda/test/parser/ets/lambda-type-inference-no-ret-type-expected.txt +++ b/ets2panda/test/parser/ets/lambda-type-inference-no-ret-type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-no-ret-type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-no-ret-type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-no-ret-type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-no-ret-type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-no-ret-type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-no-ret-type.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-type-inference-overloaded-2-expected.txt b/ets2panda/test/parser/ets/lambda-type-inference-overloaded-2-expected.txt index c630d0ee9c..1aaf04ee6b 100644 --- a/ets2panda/test/parser/ets/lambda-type-inference-overloaded-2-expected.txt +++ b/ets2panda/test/parser/ets/lambda-type-inference-overloaded-2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-2.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda-type-inference-overloaded-3-expected.txt b/ets2panda/test/parser/ets/lambda-type-inference-overloaded-3-expected.txt index e5fc5b698a..5553b71d0c 100644 --- a/ets2panda/test/parser/ets/lambda-type-inference-overloaded-3-expected.txt +++ b/ets2panda/test/parser/ets/lambda-type-inference-overloaded-3-expected.txt @@ -1205,12 +1205,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" } } }, @@ -1218,12 +1218,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" } } }, @@ -1231,12 +1231,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" } } }, @@ -1311,12 +1311,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" } } }, @@ -1324,12 +1324,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" } } }, @@ -1337,12 +1337,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda-type-inference-overloaded-3.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambdaAsFunctionParam-expected.txt b/ets2panda/test/parser/ets/lambdaAsFunctionParam-expected.txt index 3c4953d846..6911e73854 100644 --- a/ets2panda/test/parser/ets/lambdaAsFunctionParam-expected.txt +++ b/ets2panda/test/parser/ets/lambdaAsFunctionParam-expected.txt @@ -843,12 +843,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaAsFunctionParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaAsFunctionParam.ets" } } }, @@ -856,12 +856,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaAsFunctionParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaAsFunctionParam.ets" } } }, @@ -869,12 +869,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaAsFunctionParam.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaAsFunctionParam.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatement-expected.txt b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatement-expected.txt index 0574d6b087..530d73f802 100644 --- a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatement-expected.txt +++ b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatement-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatement.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatement.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatement.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatement.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementCallAVoidFunction-expected.txt b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementCallAVoidFunction-expected.txt index 1f25f4c85d..b31993dd82 100644 --- a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementCallAVoidFunction-expected.txt +++ b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementCallAVoidFunction-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementCallAVoidFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementCallAVoidFunction.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementCallAVoidFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementCallAVoidFunction.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementCallAVoidFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementCallAVoidFunction.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementVoid-expected.txt b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementVoid-expected.txt index 67e9abfc7f..b02bc9c0d1 100644 --- a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementVoid-expected.txt +++ b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementVoid-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementVoid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementVoid.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementVoid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementVoid.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementVoid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementVoid.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementWithFunctionParameters-expected.txt b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementWithFunctionParameters-expected.txt index 7e1877d4d1..3030f08377 100644 --- a/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementWithFunctionParameters-expected.txt +++ b/ets2panda/test/parser/ets/lambdaExpressionWithoutBlockStatementWithFunctionParameters-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementWithFunctionParameters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementWithFunctionParameters.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementWithFunctionParameters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementWithFunctionParameters.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementWithFunctionParameters.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaExpressionWithoutBlockStatementWithFunctionParameters.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambdaThrowsRethrows-expected.txt b/ets2panda/test/parser/ets/lambdaThrowsRethrows-expected.txt index dc195cfcfa..bd0a01e4a1 100644 --- a/ets2panda/test/parser/ets/lambdaThrowsRethrows-expected.txt +++ b/ets2panda/test/parser/ets/lambdaThrowsRethrows-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaThrowsRethrows.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaThrowsRethrows.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambdaThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambdaThrowsRethrows.ets" } } }, @@ -575,40 +575,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambdaThrowsRethrows.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 133, + "program": "lambdaThrowsRethrows.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambdaThrowsRethrows.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 133, + "program": "lambdaThrowsRethrows.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "lambdaThrowsRethrows.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 133, + "program": "lambdaThrowsRethrows.ets" } } }, @@ -616,13 +616,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "lambdaThrowsRethrows.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 133, "program": "lambdaThrowsRethrows.ets" } } diff --git a/ets2panda/test/parser/ets/lambda_import_alias_1-2-expected.txt b/ets2panda/test/parser/ets/lambda_import_alias_1-2-expected.txt index 7ed7954420..a2c4abe493 100644 --- a/ets2panda/test/parser/ets/lambda_import_alias_1-2-expected.txt +++ b/ets2panda/test/parser/ets/lambda_import_alias_1-2-expected.txt @@ -256,12 +256,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-2.ets" } } }, @@ -269,12 +269,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-2.ets" } } }, @@ -282,12 +282,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-2.ets" } } }, @@ -460,40 +460,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "lambda_import_alias_1-2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 42, + "program": "lambda_import_alias_1-2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "lambda_import_alias_1-2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 42, + "program": "lambda_import_alias_1-2.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 12, + "program": "lambda_import_alias_1-2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 42, + "program": "lambda_import_alias_1-2.ets" } } }, @@ -501,13 +501,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 12, "program": "lambda_import_alias_1-2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 42, "program": "lambda_import_alias_1-2.ets" } } diff --git a/ets2panda/test/parser/ets/lambda_import_alias_1-3-expected.txt b/ets2panda/test/parser/ets/lambda_import_alias_1-3-expected.txt index d4342619d3..c1be66990a 100644 --- a/ets2panda/test/parser/ets/lambda_import_alias_1-3-expected.txt +++ b/ets2panda/test/parser/ets/lambda_import_alias_1-3-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1-3.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda_import_alias_1-expected.txt b/ets2panda/test/parser/ets/lambda_import_alias_1-expected.txt index e640881cb6..b7cd2b9060 100644 --- a/ets2panda/test/parser/ets/lambda_import_alias_1-expected.txt +++ b/ets2panda/test/parser/ets/lambda_import_alias_1-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" } } }, @@ -251,12 +251,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" } } }, @@ -264,12 +264,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" } } }, @@ -277,12 +277,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_import_alias_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/lambda_optional_param_1-expected.txt b/ets2panda/test/parser/ets/lambda_optional_param_1-expected.txt index cf1ddbd9f3..11757bec85 100644 --- a/ets2panda/test/parser/ets/lambda_optional_param_1-expected.txt +++ b/ets2panda/test/parser/ets/lambda_optional_param_1-expected.txt @@ -490,12 +490,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" } } }, @@ -503,12 +503,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" } } }, @@ -516,12 +516,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" } } }, @@ -596,12 +596,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" } } }, @@ -609,12 +609,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" } } }, @@ -622,12 +622,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "lambda_optional_param_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/launch-expected.txt b/ets2panda/test/parser/ets/launch-expected.txt index ae4da00d7d..98f6cb3e8d 100755 --- a/ets2panda/test/parser/ets/launch-expected.txt +++ b/ets2panda/test/parser/ets/launch-expected.txt @@ -863,12 +863,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch.ets" } } }, @@ -876,12 +876,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch.ets" } } }, @@ -889,12 +889,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch.ets" } } }, diff --git a/ets2panda/test/parser/ets/launch_function_returning_void-expected.txt b/ets2panda/test/parser/ets/launch_function_returning_void-expected.txt index 5d1e83c6af..2bfacd3799 100644 --- a/ets2panda/test/parser/ets/launch_function_returning_void-expected.txt +++ b/ets2panda/test/parser/ets/launch_function_returning_void-expected.txt @@ -244,12 +244,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_function_returning_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_function_returning_void.ets" } } }, @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_function_returning_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_function_returning_void.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_function_returning_void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_function_returning_void.ets" } } }, diff --git a/ets2panda/test/parser/ets/launch_ret-expected.txt b/ets2panda/test/parser/ets/launch_ret-expected.txt index 4180ac8afb..6ad6445449 100644 --- a/ets2panda/test/parser/ets/launch_ret-expected.txt +++ b/ets2panda/test/parser/ets/launch_ret-expected.txt @@ -244,12 +244,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_ret.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_ret.ets" } } }, @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_ret.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_ret.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_ret.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_ret.ets" } } }, diff --git a/ets2panda/test/parser/ets/launch_super-expected.txt b/ets2panda/test/parser/ets/launch_super-expected.txt index 1b6eb96188..960994031d 100755 --- a/ets2panda/test/parser/ets/launch_super-expected.txt +++ b/ets2panda/test/parser/ets/launch_super-expected.txt @@ -923,12 +923,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" } } }, @@ -936,12 +936,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" } } }, @@ -949,12 +949,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" } } }, @@ -1029,12 +1029,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" } } }, @@ -1042,12 +1042,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" } } }, @@ -1055,12 +1055,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_super.ets" } } }, diff --git a/ets2panda/test/parser/ets/launch_this_callee-expected.txt b/ets2panda/test/parser/ets/launch_this_callee-expected.txt index 2c2a447576..f4c5f717d4 100755 --- a/ets2panda/test/parser/ets/launch_this_callee-expected.txt +++ b/ets2panda/test/parser/ets/launch_this_callee-expected.txt @@ -2119,12 +2119,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" } } }, @@ -2132,12 +2132,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" } } }, @@ -2145,12 +2145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" } } }, @@ -2225,12 +2225,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" } } }, @@ -2238,12 +2238,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" } } }, @@ -2251,12 +2251,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_this_callee.ets" } } }, diff --git a/ets2panda/test/parser/ets/launch_with_call_expression-expected.txt b/ets2panda/test/parser/ets/launch_with_call_expression-expected.txt index d242fffc6c..99e41b80df 100644 --- a/ets2panda/test/parser/ets/launch_with_call_expression-expected.txt +++ b/ets2panda/test/parser/ets/launch_with_call_expression-expected.txt @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_with_call_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_with_call_expression.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_with_call_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_with_call_expression.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "launch_with_call_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "launch_with_call_expression.ets" } } }, @@ -643,40 +643,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 5, + "program": "launch_with_call_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 42, + "program": "launch_with_call_expression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 5, + "program": "launch_with_call_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 42, + "program": "launch_with_call_expression.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 5, + "program": "launch_with_call_expression.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 42, + "program": "launch_with_call_expression.ets" } } }, @@ -684,13 +684,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 21, + "column": 5, "program": "launch_with_call_expression.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 42, "program": "launch_with_call_expression.ets" } } diff --git a/ets2panda/test/parser/ets/literals-expected.txt b/ets2panda/test/parser/ets/literals-expected.txt index 5dffbbbbf6..8d76b41374 100644 --- a/ets2panda/test/parser/ets/literals-expected.txt +++ b/ets2panda/test/parser/ets/literals-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "literals.ets" } } }, diff --git a/ets2panda/test/parser/ets/local-class-expected.txt b/ets2panda/test/parser/ets/local-class-expected.txt index 8b51c20764..2936ab5208 100644 --- a/ets2panda/test/parser/ets/local-class-expected.txt +++ b/ets2panda/test/parser/ets/local-class-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "local-class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "local-class.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "local-class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "local-class.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "local-class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "local-class.ets" } } }, diff --git a/ets2panda/test/parser/ets/local-interface-expected.txt b/ets2panda/test/parser/ets/local-interface-expected.txt index 0644552646..f9c416f770 100644 --- a/ets2panda/test/parser/ets/local-interface-expected.txt +++ b/ets2panda/test/parser/ets/local-interface-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "local-interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "local-interface.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "local-interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "local-interface.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "local-interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "local-interface.ets" } } }, diff --git a/ets2panda/test/parser/ets/localClassIsPermitted-expected.txt b/ets2panda/test/parser/ets/localClassIsPermitted-expected.txt index 0995504c47..aeb1fbbf32 100644 --- a/ets2panda/test/parser/ets/localClassIsPermitted-expected.txt +++ b/ets2panda/test/parser/ets/localClassIsPermitted-expected.txt @@ -473,12 +473,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" } } }, @@ -486,12 +486,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" } } }, @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" } } }, @@ -579,12 +579,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" } } }, @@ -592,12 +592,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" } } }, @@ -605,12 +605,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localClassIsPermitted.ets" } } }, diff --git a/ets2panda/test/parser/ets/localTypeAlias-expected.txt b/ets2panda/test/parser/ets/localTypeAlias-expected.txt index 5e09636f3b..5a63a7ed34 100644 --- a/ets2panda/test/parser/ets/localTypeAlias-expected.txt +++ b/ets2panda/test/parser/ets/localTypeAlias-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localTypeAlias.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localTypeAlias.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "localTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "localTypeAlias.ets" } } }, diff --git a/ets2panda/test/parser/ets/main_entry_point_1-expected.txt b/ets2panda/test/parser/ets/main_entry_point_1-expected.txt index 94f1e5a503..4d5a07a4a6 100644 --- a/ets2panda/test/parser/ets/main_entry_point_1-expected.txt +++ b/ets2panda/test/parser/ets/main_entry_point_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/main_entry_point_6-expected.txt b/ets2panda/test/parser/ets/main_entry_point_6-expected.txt index 5f3bcb8a34..e439d324dc 100644 --- a/ets2panda/test/parser/ets/main_entry_point_6-expected.txt +++ b/ets2panda/test/parser/ets/main_entry_point_6-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_6.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_6.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/main_entry_point_7-expected.txt b/ets2panda/test/parser/ets/main_entry_point_7-expected.txt index 2f96192fae..cda558b8dc 100644 --- a/ets2panda/test/parser/ets/main_entry_point_7-expected.txt +++ b/ets2panda/test/parser/ets/main_entry_point_7-expected.txt @@ -622,12 +622,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_7.ets" } } }, @@ -635,12 +635,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_7.ets" } } }, @@ -648,12 +648,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/main_entry_point_8-expected.txt b/ets2panda/test/parser/ets/main_entry_point_8-expected.txt index 38d77076f5..7311fff7cc 100644 --- a/ets2panda/test/parser/ets/main_entry_point_8-expected.txt +++ b/ets2panda/test/parser/ets/main_entry_point_8-expected.txt @@ -159,12 +159,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_8.ets" } } }, @@ -172,12 +172,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_8.ets" } } }, @@ -185,12 +185,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_8.ets" } } }, diff --git a/ets2panda/test/parser/ets/main_entry_point_9-expected.txt b/ets2panda/test/parser/ets/main_entry_point_9-expected.txt index 0828ec25dd..e85777b713 100644 --- a/ets2panda/test/parser/ets/main_entry_point_9-expected.txt +++ b/ets2panda/test/parser/ets/main_entry_point_9-expected.txt @@ -223,12 +223,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_9.ets" } } }, @@ -236,12 +236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_9.ets" } } }, @@ -249,12 +249,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "main_entry_point_9.ets" } } }, diff --git a/ets2panda/test/parser/ets/methodThrowsRethrows-expected.txt b/ets2panda/test/parser/ets/methodThrowsRethrows-expected.txt index 093b36752f..a61e13a38f 100644 --- a/ets2panda/test/parser/ets/methodThrowsRethrows-expected.txt +++ b/ets2panda/test/parser/ets/methodThrowsRethrows-expected.txt @@ -639,12 +639,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" } } }, @@ -652,12 +652,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" } } }, @@ -665,12 +665,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" } } }, @@ -745,12 +745,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" } } }, @@ -758,12 +758,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" } } }, @@ -771,12 +771,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "methodThrowsRethrows.ets" } } }, diff --git a/ets2panda/test/parser/ets/method_empty-expected.txt b/ets2panda/test/parser/ets/method_empty-expected.txt index 3157560667..5ff7ee0eee 100644 --- a/ets2panda/test/parser/ets/method_empty-expected.txt +++ b/ets2panda/test/parser/ets/method_empty-expected.txt @@ -695,12 +695,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" } } }, @@ -708,12 +708,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" } } }, @@ -721,12 +721,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" } } }, @@ -801,12 +801,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" } } }, @@ -814,12 +814,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" } } }, @@ -827,12 +827,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_empty.ets" } } }, diff --git a/ets2panda/test/parser/ets/method_modifier_check_14-expected.txt b/ets2panda/test/parser/ets/method_modifier_check_14-expected.txt index a72193ec3b..4561f88dd7 100644 --- a/ets2panda/test/parser/ets/method_modifier_check_14-expected.txt +++ b/ets2panda/test/parser/ets/method_modifier_check_14-expected.txt @@ -340,12 +340,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" } } }, @@ -353,12 +353,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" } } }, @@ -366,12 +366,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" } } }, @@ -446,12 +446,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" } } }, @@ -459,12 +459,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" } } }, @@ -472,12 +472,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_14.ets" } } }, diff --git a/ets2panda/test/parser/ets/method_modifier_check_8-expected.txt b/ets2panda/test/parser/ets/method_modifier_check_8-expected.txt index d255a51765..5d6ec8c4db 100644 --- a/ets2panda/test/parser/ets/method_modifier_check_8-expected.txt +++ b/ets2panda/test/parser/ets/method_modifier_check_8-expected.txt @@ -340,12 +340,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" } } }, @@ -353,12 +353,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" } } }, @@ -366,12 +366,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" } } }, @@ -446,12 +446,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" } } }, @@ -459,12 +459,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" } } }, @@ -472,12 +472,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_modifier_check_8.ets" } } }, diff --git a/ets2panda/test/parser/ets/method_override_throw_1-expected.txt b/ets2panda/test/parser/ets/method_override_throw_1-expected.txt index c04044c9c4..c0514cc782 100644 --- a/ets2panda/test/parser/ets/method_override_throw_1-expected.txt +++ b/ets2panda/test/parser/ets/method_override_throw_1-expected.txt @@ -2376,12 +2376,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" } } }, @@ -2389,12 +2389,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" } } }, @@ -2402,12 +2402,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" } } }, @@ -2482,12 +2482,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" } } }, @@ -2495,12 +2495,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" } } }, @@ -2508,12 +2508,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "method_override_throw_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/native_function_with_return_type-expected.txt b/ets2panda/test/parser/ets/native_function_with_return_type-expected.txt index f5983b0409..d725fa5737 100644 --- a/ets2panda/test/parser/ets/native_function_with_return_type-expected.txt +++ b/ets2panda/test/parser/ets/native_function_with_return_type-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_function_with_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_function_with_return_type.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_function_with_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_function_with_return_type.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "native_function_with_return_type.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "native_function_with_return_type.ets" } } }, diff --git a/ets2panda/test/parser/ets/new_expressions-expected.txt b/ets2panda/test/parser/ets/new_expressions-expected.txt index d7870311d6..1f42372e3e 100644 --- a/ets2panda/test/parser/ets/new_expressions-expected.txt +++ b/ets2panda/test/parser/ets/new_expressions-expected.txt @@ -236,12 +236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "new_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "new_expressions.ets" } } }, @@ -249,12 +249,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "new_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "new_expressions.ets" } } }, @@ -262,12 +262,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "new_expressions.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "new_expressions.ets" } } }, diff --git a/ets2panda/test/parser/ets/new_object_3-expected.txt b/ets2panda/test/parser/ets/new_object_3-expected.txt index 02a6235f92..645a973ec7 100644 --- a/ets2panda/test/parser/ets/new_object_3-expected.txt +++ b/ets2panda/test/parser/ets/new_object_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "new_object_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "new_object_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "new_object_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "new_object_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "new_object_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "new_object_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/null-expected.txt b/ets2panda/test/parser/ets/null-expected.txt index 20a8cfeb5c..9364cf0b91 100644 --- a/ets2panda/test/parser/ets/null-expected.txt +++ b/ets2panda/test/parser/ets/null-expected.txt @@ -409,40 +409,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "null.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 25, + "program": "null.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "null.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 25, + "program": "null.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 5, + "program": "null.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 25, + "program": "null.ets" } } }, @@ -450,13 +450,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 18, + "column": 5, "program": "null.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 25, "program": "null.ets" } } diff --git a/ets2panda/test/parser/ets/null_valid-expected.txt b/ets2panda/test/parser/ets/null_valid-expected.txt index f4d0b80cdb..9166813212 100644 --- a/ets2panda/test/parser/ets/null_valid-expected.txt +++ b/ets2panda/test/parser/ets/null_valid-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_valid.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_valid.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "null_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "null_valid.ets" } } }, @@ -250,40 +250,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "null_valid.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 26, + "program": "null_valid.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "null_valid.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 26, + "program": "null_valid.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "null_valid.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 26, + "program": "null_valid.ets" } } }, @@ -291,13 +291,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "null_valid.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 26, "program": "null_valid.ets" } } diff --git a/ets2panda/test/parser/ets/nullableGenericSignature-expected.txt b/ets2panda/test/parser/ets/nullableGenericSignature-expected.txt index c168acc981..ccbb04f900 100644 --- a/ets2panda/test/parser/ets/nullableGenericSignature-expected.txt +++ b/ets2panda/test/parser/ets/nullableGenericSignature-expected.txt @@ -909,12 +909,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" } } }, @@ -922,12 +922,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" } } }, @@ -935,12 +935,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" } } }, @@ -1015,12 +1015,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" } } }, @@ -1028,12 +1028,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" } } }, @@ -1041,12 +1041,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullableGenericSignature.ets" } } }, diff --git a/ets2panda/test/parser/ets/nullable_union_array-expected.txt b/ets2panda/test/parser/ets/nullable_union_array-expected.txt index d3f3de9f16..284320e7ef 100644 --- a/ets2panda/test/parser/ets/nullable_union_array-expected.txt +++ b/ets2panda/test/parser/ets/nullable_union_array-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_union_array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_union_array.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_union_array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_union_array.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "nullable_union_array.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "nullable_union_array.ets" } } }, diff --git a/ets2panda/test/parser/ets/object-expected.txt b/ets2panda/test/parser/ets/object-expected.txt index 636e38a147..d1dd4a7434 100644 --- a/ets2panda/test/parser/ets/object-expected.txt +++ b/ets2panda/test/parser/ets/object-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "object.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "object.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "object.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "object.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "object.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "object.ets" } } }, diff --git a/ets2panda/test/parser/ets/optional_field_class-expected.txt b/ets2panda/test/parser/ets/optional_field_class-expected.txt index f7512ccce8..884726ec67 100644 --- a/ets2panda/test/parser/ets/optional_field_class-expected.txt +++ b/ets2panda/test/parser/ets/optional_field_class-expected.txt @@ -473,12 +473,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" } } }, @@ -486,12 +486,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" } } }, @@ -499,12 +499,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" } } }, @@ -579,12 +579,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" } } }, @@ -592,12 +592,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" } } }, @@ -605,12 +605,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_class.ets" } } }, diff --git a/ets2panda/test/parser/ets/optional_field_interface-expected.txt b/ets2panda/test/parser/ets/optional_field_interface-expected.txt index d96c964004..d571246007 100644 --- a/ets2panda/test/parser/ets/optional_field_interface-expected.txt +++ b/ets2panda/test/parser/ets/optional_field_interface-expected.txt @@ -1406,12 +1406,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" } } }, @@ -1419,12 +1419,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" } } }, @@ -1432,12 +1432,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" } } }, @@ -1512,12 +1512,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" } } }, @@ -1525,12 +1525,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" } } }, @@ -1538,12 +1538,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interface.ets" } } }, diff --git a/ets2panda/test/parser/ets/optional_field_interfaceUnion-expected.txt b/ets2panda/test/parser/ets/optional_field_interfaceUnion-expected.txt index 7b334ffa2e..6745a20af4 100644 --- a/ets2panda/test/parser/ets/optional_field_interfaceUnion-expected.txt +++ b/ets2panda/test/parser/ets/optional_field_interfaceUnion-expected.txt @@ -1769,12 +1769,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" } } }, @@ -1782,12 +1782,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" } } }, @@ -1795,12 +1795,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" } } }, @@ -1875,12 +1875,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" } } }, @@ -1888,12 +1888,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" } } }, @@ -1901,12 +1901,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_field_interfaceUnion.ets" } } }, diff --git a/ets2panda/test/parser/ets/optional_union_paramter-expected.txt b/ets2panda/test/parser/ets/optional_union_paramter-expected.txt index ed1274a9ea..27cb8be9b1 100644 --- a/ets2panda/test/parser/ets/optional_union_paramter-expected.txt +++ b/ets2panda/test/parser/ets/optional_union_paramter-expected.txt @@ -876,12 +876,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_union_paramter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_union_paramter.ets" } } }, @@ -889,12 +889,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_union_paramter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_union_paramter.ets" } } }, @@ -902,12 +902,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "optional_union_paramter.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "optional_union_paramter.ets" } } }, diff --git a/ets2panda/test/parser/ets/override-expected.txt b/ets2panda/test/parser/ets/override-expected.txt index 64a1433e4e..5f5fa18a95 100644 --- a/ets2panda/test/parser/ets/override-expected.txt +++ b/ets2panda/test/parser/ets/override-expected.txt @@ -1592,12 +1592,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override.ets" } } }, @@ -1605,12 +1605,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override.ets" } } }, @@ -1618,12 +1618,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "override.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "override.ets" } } }, diff --git a/ets2panda/test/parser/ets/overrideStaticFunc-expected.txt b/ets2panda/test/parser/ets/overrideStaticFunc-expected.txt index 3c52f8c03c..db4a5946fa 100644 --- a/ets2panda/test/parser/ets/overrideStaticFunc-expected.txt +++ b/ets2panda/test/parser/ets/overrideStaticFunc-expected.txt @@ -849,12 +849,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" } } }, @@ -862,12 +862,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" } } }, @@ -875,12 +875,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" } } }, @@ -955,12 +955,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" } } }, @@ -968,12 +968,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" } } }, @@ -981,12 +981,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "overrideStaticFunc.ets" } } }, diff --git a/ets2panda/test/parser/ets/parentheses_expression_value-expected.txt b/ets2panda/test/parser/ets/parentheses_expression_value-expected.txt index 04752bd0e5..0f165ffb93 100644 --- a/ets2panda/test/parser/ets/parentheses_expression_value-expected.txt +++ b/ets2panda/test/parser/ets/parentheses_expression_value-expected.txt @@ -336,40 +336,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "parentheses_expression_value.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 12, + "program": "parentheses_expression_value.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "parentheses_expression_value.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 12, + "program": "parentheses_expression_value.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "parentheses_expression_value.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 12, + "program": "parentheses_expression_value.ets" } } }, @@ -377,13 +377,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "parentheses_expression_value.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 12, "program": "parentheses_expression_value.ets" } } diff --git a/ets2panda/test/parser/ets/predefined_types-expected.txt b/ets2panda/test/parser/ets/predefined_types-expected.txt index 7d6959d452..b3365f114b 100644 --- a/ets2panda/test/parser/ets/predefined_types-expected.txt +++ b/ets2panda/test/parser/ets/predefined_types-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "predefined_types.ets" } } }, diff --git a/ets2panda/test/parser/ets/promiseCasting-expected.txt b/ets2panda/test/parser/ets/promiseCasting-expected.txt index 42bca8fa4c..88fe68f0e7 100644 --- a/ets2panda/test/parser/ets/promiseCasting-expected.txt +++ b/ets2panda/test/parser/ets/promiseCasting-expected.txt @@ -418,40 +418,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 5, + "program": "promiseCasting.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 18, + "program": "promiseCasting.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 5, + "program": "promiseCasting.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 18, + "program": "promiseCasting.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 5, + "program": "promiseCasting.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 21, + "column": 18, + "program": "promiseCasting.ets" } } }, @@ -459,13 +459,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 21, + "column": 5, "program": "promiseCasting.ets" }, "end": { - "line": 1, - "column": 1, + "line": 21, + "column": 18, "program": "promiseCasting.ets" } } diff --git a/ets2panda/test/parser/ets/proxyVoidGeneration-expected.txt b/ets2panda/test/parser/ets/proxyVoidGeneration-expected.txt index f6c9b7b863..91269d01ca 100644 --- a/ets2panda/test/parser/ets/proxyVoidGeneration-expected.txt +++ b/ets2panda/test/parser/ets/proxyVoidGeneration-expected.txt @@ -1294,12 +1294,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "proxyVoidGeneration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "proxyVoidGeneration.ets" } } }, @@ -1307,12 +1307,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "proxyVoidGeneration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "proxyVoidGeneration.ets" } } }, @@ -1320,12 +1320,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "proxyVoidGeneration.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "proxyVoidGeneration.ets" } } }, diff --git a/ets2panda/test/parser/ets/proxy_method-expected.txt b/ets2panda/test/parser/ets/proxy_method-expected.txt index 8284204945..390eb558a4 100644 --- a/ets2panda/test/parser/ets/proxy_method-expected.txt +++ b/ets2panda/test/parser/ets/proxy_method-expected.txt @@ -786,12 +786,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "proxy_method.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "proxy_method.ets" } } }, @@ -799,12 +799,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "proxy_method.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "proxy_method.ets" } } }, @@ -812,12 +812,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "proxy_method.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "proxy_method.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/diamond/A-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/A-expected.txt index 615f5ec208..2fca16dd7e 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/A-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/A-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "A.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "A.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "A.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "A.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "A.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "A.ets" } } }, @@ -249,40 +249,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "A.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 31, + "program": "A.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "A.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 31, + "program": "A.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 12, + "program": "A.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 31, + "program": "A.ets" } } }, @@ -290,13 +290,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 12, "program": "A.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 31, "program": "A.ets" } } diff --git a/ets2panda/test/parser/ets/re_export/diamond/B-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/B-expected.txt index 696c8558c3..8ef2662022 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/B-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/B-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/diamond/B2-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/B2-expected.txt index ce3d378573..3a977a9df9 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/B2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/B2-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "B2.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/diamond/C-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/C-expected.txt index 6e85e269d6..ff95b7e94e 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/C-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/C-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/diamond/C2-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/C2-expected.txt index 89615244b9..c77974a630 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/C2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/C2-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "C2.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/diamond/D-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/D-expected.txt index 87ef6e7f53..6f5a5dd555 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/D-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/D-expected.txt @@ -210,12 +210,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "D.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "D.ets" } } }, @@ -223,12 +223,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "D.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "D.ets" } } }, @@ -236,12 +236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "D.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "D.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/diamond/D2-expected.txt b/ets2panda/test/parser/ets/re_export/diamond/D2-expected.txt index 9fe8f42c76..cb0d70915c 100644 --- a/ets2panda/test/parser/ets/re_export/diamond/D2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/diamond/D2-expected.txt @@ -210,12 +210,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "D2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "D2.ets" } } }, @@ -223,12 +223,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "D2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "D2.ets" } } }, @@ -236,12 +236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "D2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "D2.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/export-expected.txt b/ets2panda/test/parser/ets/re_export/export-expected.txt index c10cf4198c..d218cf7bf7 100644 --- a/ets2panda/test/parser/ets/re_export/export-expected.txt +++ b/ets2panda/test/parser/ets/re_export/export-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/export_2-expected.txt b/ets2panda/test/parser/ets/re_export/export_2-expected.txt index a78d3223db..cafb9dafff 100644 --- a/ets2panda/test/parser/ets/re_export/export_2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/export_2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/export_3-expected.txt b/ets2panda/test/parser/ets/re_export/export_3-expected.txt index 990e3c747c..de4fbdc68d 100644 --- a/ets2panda/test/parser/ets/re_export/export_3-expected.txt +++ b/ets2panda/test/parser/ets/re_export/export_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folder/export-expected.txt b/ets2panda/test/parser/ets/re_export/folder/export-expected.txt index c10cf4198c..d218cf7bf7 100644 --- a/ets2panda/test/parser/ets/re_export/folder/export-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folder/export-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folder/folder2/export-expected.txt b/ets2panda/test/parser/ets/re_export/folder/folder2/export-expected.txt index c10cf4198c..d218cf7bf7 100644 --- a/ets2panda/test/parser/ets/re_export/folder/folder2/export-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folder/folder2/export-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "export.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folder/re_export_6-expected.txt b/ets2panda/test/parser/ets/re_export/folder/re_export_6-expected.txt index 10e735b0e9..1022fd4b89 100644 --- a/ets2panda/test/parser/ets/re_export/folder/re_export_6-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folder/re_export_6-expected.txt @@ -160,12 +160,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" } } }, @@ -173,12 +173,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" } } }, @@ -266,12 +266,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" } } }, @@ -279,12 +279,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" } } }, @@ -292,12 +292,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folder/re_export_7-expected.txt b/ets2panda/test/parser/ets/re_export/folder/re_export_7-expected.txt index e00178f99c..d16c8c4f9c 100644 --- a/ets2panda/test/parser/ets/re_export/folder/re_export_7-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folder/re_export_7-expected.txt @@ -160,12 +160,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -173,12 +173,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -266,12 +266,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -279,12 +279,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -292,12 +292,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folderIndex/index-expected.txt b/ets2panda/test/parser/ets/re_export/folderIndex/index-expected.txt index 5a0839b190..faec4644af 100644 --- a/ets2panda/test/parser/ets/re_export/folderIndex/index-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folderIndex/index-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folderIndex/test-expected.txt b/ets2panda/test/parser/ets/re_export/folderIndex/test-expected.txt index a429b641b1..3cd598a097 100644 --- a/ets2panda/test/parser/ets/re_export/folderIndex/test-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folderIndex/test-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folderIndex2/index-expected.txt b/ets2panda/test/parser/ets/re_export/folderIndex2/index-expected.txt index 01b819fb79..346d5aec80 100644 --- a/ets2panda/test/parser/ets/re_export/folderIndex2/index-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folderIndex2/index-expected.txt @@ -274,12 +274,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -287,12 +287,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -300,12 +300,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -380,12 +380,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -393,12 +393,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, @@ -406,12 +406,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "index.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/folderIndex2/key-expected.txt b/ets2panda/test/parser/ets/re_export/folderIndex2/key-expected.txt index adce9c43d8..ce641d8b5c 100644 --- a/ets2panda/test/parser/ets/re_export/folderIndex2/key-expected.txt +++ b/ets2panda/test/parser/ets/re_export/folderIndex2/key-expected.txt @@ -596,12 +596,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "key.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "key.ets" } } }, @@ -609,12 +609,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "key.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "key.ets" } } }, @@ -622,12 +622,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "key.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "key.ets" } } }, @@ -702,12 +702,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "key.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "key.ets" } } }, @@ -715,12 +715,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "key.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "key.ets" } } }, @@ -728,12 +728,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "key.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "key.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import-expected.txt b/ets2panda/test/parser/ets/re_export/import-expected.txt index c4555cef6a..5fff7bf409 100644 --- a/ets2panda/test/parser/ets/re_export/import-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_10-expected.txt b/ets2panda/test/parser/ets/re_export/import_10-expected.txt index 2152202423..a4098ad70b 100644 --- a/ets2panda/test/parser/ets/re_export/import_10-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_10-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_10.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_10.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_10.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_11-expected.txt b/ets2panda/test/parser/ets/re_export/import_11-expected.txt index ea9d0aaa0d..30a6ebf358 100644 --- a/ets2panda/test/parser/ets/re_export/import_11-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_11-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_11.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_11.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_11.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_12-expected.txt b/ets2panda/test/parser/ets/re_export/import_12-expected.txt index 26aac25beb..4388c55b71 100644 --- a/ets2panda/test/parser/ets/re_export/import_12-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_12-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_12.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_12.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_12.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_13-expected.txt b/ets2panda/test/parser/ets/re_export/import_13-expected.txt index 071835ff81..4d09855833 100644 --- a/ets2panda/test/parser/ets/re_export/import_13-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_13-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_13.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_13.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_13.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_13.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_14-expected.txt b/ets2panda/test/parser/ets/re_export/import_14-expected.txt index baf95e0b3b..dbacd9840b 100644 --- a/ets2panda/test/parser/ets/re_export/import_14-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_14-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_14.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_14.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_14.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_14.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_15-expected.txt b/ets2panda/test/parser/ets/re_export/import_15-expected.txt index c8d44adc39..f13f3a48df 100644 --- a/ets2panda/test/parser/ets/re_export/import_15-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_15-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_15.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_15.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_15.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_15.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_15.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_15.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_2-expected.txt b/ets2panda/test/parser/ets/re_export/import_2-expected.txt index 415dd9dd6e..2189edea67 100644 --- a/ets2panda/test/parser/ets/re_export/import_2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_2-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_3-expected.txt b/ets2panda/test/parser/ets/re_export/import_3-expected.txt index f7d16ecb3c..bf23ed8851 100644 --- a/ets2panda/test/parser/ets/re_export/import_3-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_3-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_6-expected.txt b/ets2panda/test/parser/ets/re_export/import_6-expected.txt index 89385a92b7..85d2235752 100644 --- a/ets2panda/test/parser/ets/re_export/import_6-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_6-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_6.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_6.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_6.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_7-expected.txt b/ets2panda/test/parser/ets/re_export/import_7-expected.txt index 61bdc33e1d..7969d5840b 100644 --- a/ets2panda/test/parser/ets/re_export/import_7-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_7-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_7.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_7.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_8-expected.txt b/ets2panda/test/parser/ets/re_export/import_8-expected.txt index a2ec621913..def3925024 100644 --- a/ets2panda/test/parser/ets/re_export/import_8-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_8-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_8.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_8.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_8.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_9-expected.txt b/ets2panda/test/parser/ets/re_export/import_9-expected.txt index 147783e0d9..86ad70b08d 100644 --- a/ets2panda/test/parser/ets/re_export/import_9-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_9-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_9.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_9.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_9.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/import_index-expected.txt b/ets2panda/test/parser/ets/re_export/import_index-expected.txt index 2152c6a9d0..fda7032574 100644 --- a/ets2panda/test/parser/ets/re_export/import_index-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_index-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index.ets" } } }, @@ -333,40 +333,40 @@ ], "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_index.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 10, + "program": "import_index.ets" } } }, "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_index.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 10, + "program": "import_index.ets" } } }, "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_index.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 10, + "program": "import_index.ets" } } }, @@ -374,13 +374,13 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 18, "column": 1, "program": "import_index.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 10, "program": "import_index.ets" } } diff --git a/ets2panda/test/parser/ets/re_export/import_index_2-expected.txt b/ets2panda/test/parser/ets/re_export/import_index_2-expected.txt index 671af9dde7..a09cb3c6ef 100644 --- a/ets2panda/test/parser/ets/re_export/import_index_2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_index_2-expected.txt @@ -162,12 +162,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_2.ets" } } }, @@ -175,12 +175,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_2.ets" } } }, @@ -188,12 +188,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_2.ets" } } }, @@ -316,40 +316,40 @@ ], "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_index_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 6, + "program": "import_index_2.ets" } } }, "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_index_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 6, + "program": "import_index_2.ets" } } }, "loc": { "start": { - "line": 1, + "line": 18, "column": 1, - "program": null + "program": "import_index_2.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 18, + "column": 6, + "program": "import_index_2.ets" } } }, @@ -357,13 +357,13 @@ "decorators": [], "loc": { "start": { - "line": 1, + "line": 18, "column": 1, "program": "import_index_2.ets" }, "end": { - "line": 1, - "column": 1, + "line": 18, + "column": 6, "program": "import_index_2.ets" } } diff --git a/ets2panda/test/parser/ets/re_export/import_index_3-expected.txt b/ets2panda/test/parser/ets/re_export/import_index_3-expected.txt index 53043501ef..9da7e0aad6 100644 --- a/ets2panda/test/parser/ets/re_export/import_index_3-expected.txt +++ b/ets2panda/test/parser/ets/re_export/import_index_3-expected.txt @@ -211,12 +211,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" } } }, @@ -224,12 +224,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" } } }, @@ -237,12 +237,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" } } }, @@ -317,12 +317,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" } } }, @@ -330,12 +330,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" } } }, @@ -343,12 +343,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_index_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export-expected.txt b/ets2panda/test/parser/ets/re_export/re_export-expected.txt index f16ec402b7..bde9303b75 100644 --- a/ets2panda/test/parser/ets/re_export/re_export-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export-expected.txt @@ -160,12 +160,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" } } }, @@ -173,12 +173,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" } } }, @@ -266,12 +266,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" } } }, @@ -279,12 +279,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" } } }, @@ -292,12 +292,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_10-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_10-expected.txt index 8cf2f783ef..a0398792b9 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_10-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_10-expected.txt @@ -160,12 +160,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" } } }, @@ -173,12 +173,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" } } }, @@ -266,12 +266,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" } } }, @@ -279,12 +279,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" } } }, @@ -292,12 +292,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_10.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_11-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_11-expected.txt index 85b263f83b..597b9ab57d 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_11-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_11-expected.txt @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" } } }, @@ -363,12 +363,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" } } }, @@ -376,12 +376,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" } } }, @@ -389,12 +389,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_11.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_12-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_12-expected.txt index 2b7521bf96..28b5944b4c 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_12-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_12-expected.txt @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" } } }, @@ -266,12 +266,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" } } }, @@ -346,12 +346,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" } } }, @@ -359,12 +359,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" } } }, @@ -372,12 +372,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_12.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_2-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_2-expected.txt index d1693124bb..19d31a0039 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_2-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_2-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_3-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_3-expected.txt index 25da675026..4d0f0ea2ae 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_3-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_3-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_4-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_4-expected.txt index 23266085b0..684da16731 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_4-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_4-expected.txt @@ -274,12 +274,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" } } }, @@ -287,12 +287,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" } } }, @@ -300,12 +300,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" } } }, @@ -380,12 +380,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" } } }, @@ -393,12 +393,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" } } }, @@ -406,12 +406,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_5-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_5-expected.txt index b7a59b0bdb..613961e0f4 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_5-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_5-expected.txt @@ -240,12 +240,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" } } }, @@ -253,12 +253,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" } } }, @@ -266,12 +266,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" } } }, @@ -346,12 +346,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" } } }, @@ -359,12 +359,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" } } }, @@ -372,12 +372,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_5.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_7-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_7-expected.txt index 347afbe778..a307692765 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_7-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_7-expected.txt @@ -257,12 +257,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -270,12 +270,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -363,12 +363,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -376,12 +376,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, @@ -389,12 +389,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_7.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_8-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_8-expected.txt index eafe5f6b54..b08c31caab 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_8-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_8-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_8.ets" } } }, diff --git a/ets2panda/test/parser/ets/re_export/re_export_9-expected.txt b/ets2panda/test/parser/ets/re_export/re_export_9-expected.txt index 993f53396b..0f1e2eaee0 100644 --- a/ets2panda/test/parser/ets/re_export/re_export_9-expected.txt +++ b/ets2panda/test/parser/ets/re_export/re_export_9-expected.txt @@ -177,12 +177,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" } } }, @@ -190,12 +190,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" } } }, @@ -203,12 +203,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" } } }, @@ -283,12 +283,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" } } }, @@ -296,12 +296,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" } } }, @@ -309,12 +309,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "re_export_9.ets" } } }, diff --git a/ets2panda/test/parser/ets/regression-target-type-context-expected.txt b/ets2panda/test/parser/ets/regression-target-type-context-expected.txt index 13fefb7ff7..0f1eaa4f32 100644 --- a/ets2panda/test/parser/ets/regression-target-type-context-expected.txt +++ b/ets2panda/test/parser/ets/regression-target-type-context-expected.txt @@ -1568,12 +1568,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" } } }, @@ -1581,12 +1581,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" } } }, @@ -1594,12 +1594,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" } } }, @@ -1674,12 +1674,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" } } }, @@ -1687,12 +1687,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" } } }, @@ -1700,12 +1700,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "regression-target-type-context.ets" } } }, diff --git a/ets2panda/test/parser/ets/rest_parameter_01-expected.txt b/ets2panda/test/parser/ets/rest_parameter_01-expected.txt index 3cd64b9f99..c1fc986868 100644 --- a/ets2panda/test/parser/ets/rest_parameter_01-expected.txt +++ b/ets2panda/test/parser/ets/rest_parameter_01-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_01.ets" } } }, diff --git a/ets2panda/test/parser/ets/rest_parameter_02-expected.txt b/ets2panda/test/parser/ets/rest_parameter_02-expected.txt index ee060d72bb..3a9949c0ee 100644 --- a/ets2panda/test/parser/ets/rest_parameter_02-expected.txt +++ b/ets2panda/test/parser/ets/rest_parameter_02-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rest_parameter_02.ets" } } }, diff --git a/ets2panda/test/parser/ets/rethrow-func-1-expected.txt b/ets2panda/test/parser/ets/rethrow-func-1-expected.txt index 8e9d7e6050..225519beb7 100644 --- a/ets2panda/test/parser/ets/rethrow-func-1-expected.txt +++ b/ets2panda/test/parser/ets/rethrow-func-1-expected.txt @@ -144,12 +144,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrow-func-1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrow-func-1.ets" } } }, @@ -157,12 +157,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrow-func-1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrow-func-1.ets" } } }, @@ -170,12 +170,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "rethrow-func-1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "rethrow-func-1.ets" } } }, diff --git a/ets2panda/test/parser/ets/return-expected.txt b/ets2panda/test/parser/ets/return-expected.txt index 0fcf6104d7..4c08f545fd 100644 --- a/ets2panda/test/parser/ets/return-expected.txt +++ b/ets2panda/test/parser/ets/return-expected.txt @@ -192,40 +192,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "return.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "return.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "return.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "return.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "return.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 25, + "program": "return.ets" } } }, @@ -233,13 +233,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "return.ets" }, "end": { - "line": 1, - "column": 1, + "line": 16, + "column": 25, "program": "return.ets" } } diff --git a/ets2panda/test/parser/ets/returnNullableFromFunction-expected.txt b/ets2panda/test/parser/ets/returnNullableFromFunction-expected.txt index 9f3ab9a53f..09900e0a93 100644 --- a/ets2panda/test/parser/ets/returnNullableFromFunction-expected.txt +++ b/ets2panda/test/parser/ets/returnNullableFromFunction-expected.txt @@ -235,12 +235,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" } } }, @@ -248,12 +248,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" } } }, @@ -261,12 +261,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" } } }, @@ -341,12 +341,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" } } }, @@ -354,12 +354,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" } } }, @@ -367,12 +367,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromFunction.ets" } } }, diff --git a/ets2panda/test/parser/ets/returnNullableFromMethod-expected.txt b/ets2panda/test/parser/ets/returnNullableFromMethod-expected.txt index 805c5a6ddb..2daf1fa1ab 100644 --- a/ets2panda/test/parser/ets/returnNullableFromMethod-expected.txt +++ b/ets2panda/test/parser/ets/returnNullableFromMethod-expected.txt @@ -613,12 +613,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" } } }, @@ -626,12 +626,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" } } }, @@ -639,12 +639,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" } } }, @@ -719,12 +719,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" } } }, @@ -732,12 +732,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" } } }, @@ -745,12 +745,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "returnNullableFromMethod.ets" } } }, diff --git a/ets2panda/test/parser/ets/scoped_decl-expected.txt b/ets2panda/test/parser/ets/scoped_decl-expected.txt index 043975b70e..1b84b749f1 100644 --- a/ets2panda/test/parser/ets/scoped_decl-expected.txt +++ b/ets2panda/test/parser/ets/scoped_decl-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "scoped_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "scoped_decl.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "scoped_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "scoped_decl.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "scoped_decl.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "scoped_decl.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/import_1-expected.txt b/ets2panda/test/parser/ets/selective_export/import_1-expected.txt index 2e0577fb37..666a6fd502 100644 --- a/ets2panda/test/parser/ets/selective_export/import_1-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/import_1-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_1.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_1.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/import_2-expected.txt b/ets2panda/test/parser/ets/selective_export/import_2-expected.txt index 18ee277c6a..6676c50d1a 100644 --- a/ets2panda/test/parser/ets/selective_export/import_2-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/import_2-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/import_3-expected.txt b/ets2panda/test/parser/ets/selective_export/import_3-expected.txt index 15c116300d..7ae1968d4b 100644 --- a/ets2panda/test/parser/ets/selective_export/import_3-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/import_3-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/import_4-expected.txt b/ets2panda/test/parser/ets/selective_export/import_4-expected.txt index 65e3fa5157..d99dc85112 100644 --- a/ets2panda/test/parser/ets/selective_export/import_4-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/import_4-expected.txt @@ -145,12 +145,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_4.ets" } } }, @@ -158,12 +158,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_4.ets" } } }, @@ -171,12 +171,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "import_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "import_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/selective_export_1-expected.txt b/ets2panda/test/parser/ets/selective_export/selective_export_1-expected.txt index f2aa382e52..8518599df6 100644 --- a/ets2panda/test/parser/ets/selective_export/selective_export_1-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/selective_export_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/selective_export_2-expected.txt b/ets2panda/test/parser/ets/selective_export/selective_export_2-expected.txt index 3e7e0d9c4b..398e6f4512 100644 --- a/ets2panda/test/parser/ets/selective_export/selective_export_2-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/selective_export_2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/selective_export_3-expected.txt b/ets2panda/test/parser/ets/selective_export/selective_export_3-expected.txt index 59533da4d3..3a42897471 100644 --- a/ets2panda/test/parser/ets/selective_export/selective_export_3-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/selective_export_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/selective_export/selective_export_4-expected.txt b/ets2panda/test/parser/ets/selective_export/selective_export_4-expected.txt index 148a80d194..f6f0c98bc5 100644 --- a/ets2panda/test/parser/ets/selective_export/selective_export_4-expected.txt +++ b/ets2panda/test/parser/ets/selective_export/selective_export_4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "selective_export_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/simple_types-expected.txt b/ets2panda/test/parser/ets/simple_types-expected.txt index cc14840310..2800be6614 100644 --- a/ets2panda/test/parser/ets/simple_types-expected.txt +++ b/ets2panda/test/parser/ets/simple_types-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "simple_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "simple_types.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "simple_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "simple_types.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "simple_types.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "simple_types.ets" } } }, @@ -831,40 +831,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "simple_types.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 29, + "column": 16, + "program": "simple_types.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "simple_types.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 29, + "column": 16, + "program": "simple_types.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "simple_types.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 29, + "column": 16, + "program": "simple_types.ets" } } }, @@ -872,13 +872,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "simple_types.ets" }, "end": { - "line": 1, - "column": 1, + "line": 29, + "column": 16, "program": "simple_types.ets" } } diff --git a/ets2panda/test/parser/ets/static_function_override_1-expected.txt b/ets2panda/test/parser/ets/static_function_override_1-expected.txt index 5de5aa2765..967c5d9a6a 100644 --- a/ets2panda/test/parser/ets/static_function_override_1-expected.txt +++ b/ets2panda/test/parser/ets/static_function_override_1-expected.txt @@ -678,12 +678,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" } } }, @@ -691,12 +691,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" } } }, @@ -704,12 +704,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" } } }, @@ -797,12 +797,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" } } }, @@ -810,12 +810,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/static_function_override_2-expected.txt b/ets2panda/test/parser/ets/static_function_override_2-expected.txt index 72db14fe32..754bc9aeda 100644 --- a/ets2panda/test/parser/ets/static_function_override_2-expected.txt +++ b/ets2panda/test/parser/ets/static_function_override_2-expected.txt @@ -678,12 +678,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" } } }, @@ -691,12 +691,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" } } }, @@ -704,12 +704,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" } } }, @@ -797,12 +797,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" } } }, @@ -810,12 +810,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/static_function_override_3-expected.txt b/ets2panda/test/parser/ets/static_function_override_3-expected.txt index 4f6abf5bb8..7b7a04acea 100644 --- a/ets2panda/test/parser/ets/static_function_override_3-expected.txt +++ b/ets2panda/test/parser/ets/static_function_override_3-expected.txt @@ -678,12 +678,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" } } }, @@ -691,12 +691,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" } } }, @@ -704,12 +704,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" } } }, @@ -797,12 +797,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" } } }, @@ -810,12 +810,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "static_function_override_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/string-expected.txt b/ets2panda/test/parser/ets/string-expected.txt index cd9fbe932b..dfd562defe 100644 --- a/ets2panda/test/parser/ets/string-expected.txt +++ b/ets2panda/test/parser/ets/string-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string.ets" } } }, @@ -313,40 +313,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "string.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 24, + "program": "string.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "string.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 24, + "program": "string.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "string.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 24, + "program": "string.ets" } } }, @@ -354,13 +354,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "string.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 24, "program": "string.ets" } } diff --git a/ets2panda/test/parser/ets/string_template_1-expected.txt b/ets2panda/test/parser/ets/string_template_1-expected.txt index e422f709d3..890187012b 100644 --- a/ets2panda/test/parser/ets/string_template_1-expected.txt +++ b/ets2panda/test/parser/ets/string_template_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/string_template_2-expected.txt b/ets2panda/test/parser/ets/string_template_2-expected.txt index a84e83957e..81f1caa934 100644 --- a/ets2panda/test/parser/ets/string_template_2-expected.txt +++ b/ets2panda/test/parser/ets/string_template_2-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_2.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_2.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/string_template_3-expected.txt b/ets2panda/test/parser/ets/string_template_3-expected.txt index d0d1d2d3ec..cfb193b398 100644 --- a/ets2panda/test/parser/ets/string_template_3-expected.txt +++ b/ets2panda/test/parser/ets/string_template_3-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_3.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_3.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_3.ets" } } }, diff --git a/ets2panda/test/parser/ets/string_template_4-expected.txt b/ets2panda/test/parser/ets/string_template_4-expected.txt index c2a165a2d0..ed32e495cb 100644 --- a/ets2panda/test/parser/ets/string_template_4-expected.txt +++ b/ets2panda/test/parser/ets/string_template_4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "string_template_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "string_template_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch-expected.txt b/ets2panda/test/parser/ets/switch-expected.txt index f3c60add8c..a0f6801d62 100644 --- a/ets2panda/test/parser/ets/switch-expected.txt +++ b/ets2panda/test/parser/ets/switch-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_alive_1-expected.txt b/ets2panda/test/parser/ets/switch_alive_1-expected.txt index b353cc3ed5..fc3f469a5e 100644 --- a/ets2panda/test/parser/ets/switch_alive_1-expected.txt +++ b/ets2panda/test/parser/ets/switch_alive_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_alive_4-expected.txt b/ets2panda/test/parser/ets/switch_alive_4-expected.txt index ffc2d56df5..4974b4d79f 100644 --- a/ets2panda/test/parser/ets/switch_alive_4-expected.txt +++ b/ets2panda/test/parser/ets/switch_alive_4-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_alive_4.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_enum_string_case-expected.txt b/ets2panda/test/parser/ets/switch_enum_string_case-expected.txt index 2d3358ae91..832e0c73b8 100644 --- a/ets2panda/test/parser/ets/switch_enum_string_case-expected.txt +++ b/ets2panda/test/parser/ets/switch_enum_string_case-expected.txt @@ -5210,12 +5210,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_enum_string_case.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_enum_string_case.ets" } } }, @@ -5223,12 +5223,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_enum_string_case.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_enum_string_case.ets" } } }, @@ -5236,12 +5236,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_enum_string_case.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_enum_string_case.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_num_compare_char-expected.txt b/ets2panda/test/parser/ets/switch_num_compare_char-expected.txt index 4ac04baf6c..4e4109d1e8 100644 --- a/ets2panda/test/parser/ets/switch_num_compare_char-expected.txt +++ b/ets2panda/test/parser/ets/switch_num_compare_char-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_num_compare_char.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_num_compare_char.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_num_compare_char.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_num_compare_char.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_num_compare_char.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_num_compare_char.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_readonly_member-expected.txt b/ets2panda/test/parser/ets/switch_readonly_member-expected.txt index ab089826db..4954f89cd1 100644 --- a/ets2panda/test/parser/ets/switch_readonly_member-expected.txt +++ b/ets2panda/test/parser/ets/switch_readonly_member-expected.txt @@ -502,12 +502,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member.ets" } } }, @@ -515,12 +515,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member.ets" } } }, @@ -528,12 +528,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_readonly_member_compare_char-expected.txt b/ets2panda/test/parser/ets/switch_readonly_member_compare_char-expected.txt index fd21a4ff30..581970ee13 100644 --- a/ets2panda/test/parser/ets/switch_readonly_member_compare_char-expected.txt +++ b/ets2panda/test/parser/ets/switch_readonly_member_compare_char-expected.txt @@ -502,12 +502,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char.ets" } } }, @@ -515,12 +515,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char.ets" } } }, @@ -528,12 +528,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char.ets" } } }, diff --git a/ets2panda/test/parser/ets/switch_readonly_member_compare_char_2-expected.txt b/ets2panda/test/parser/ets/switch_readonly_member_compare_char_2-expected.txt index d9d12a2ab7..a8d6babbd9 100644 --- a/ets2panda/test/parser/ets/switch_readonly_member_compare_char_2-expected.txt +++ b/ets2panda/test/parser/ets/switch_readonly_member_compare_char_2-expected.txt @@ -502,12 +502,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char_2.ets" } } }, @@ -515,12 +515,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char_2.ets" } } }, @@ -528,12 +528,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "switch_readonly_member_compare_char_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/ternary-expected.txt b/ets2panda/test/parser/ets/ternary-expected.txt index 9e8ae9dcaa..1a8737e1cd 100644 --- a/ets2panda/test/parser/ets/ternary-expected.txt +++ b/ets2panda/test/parser/ets/ternary-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ternary.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ternary.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ternary.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ternary.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "ternary.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "ternary.ets" } } }, @@ -460,40 +460,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "ternary.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 22, + "program": "ternary.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "ternary.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 22, + "program": "ternary.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "ternary.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 22, + "program": "ternary.ets" } } }, @@ -501,13 +501,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "ternary.ets" }, "end": { - "line": 1, - "column": 1, + "line": 19, + "column": 22, "program": "ternary.ets" } } diff --git a/ets2panda/test/parser/ets/test-type-alias-call1-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call1-expected.txt index 8ac00a419b..061cc69b2d 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call1-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call1-expected.txt @@ -769,12 +769,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" } } }, @@ -782,12 +782,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" } } }, @@ -795,12 +795,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" } } }, @@ -875,12 +875,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" } } }, @@ -888,12 +888,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" } } }, @@ -901,12 +901,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call1.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call2-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call2-expected.txt index b5a969e767..7803685eb2 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call2-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call2-expected.txt @@ -927,12 +927,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" } } }, @@ -940,12 +940,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" } } }, @@ -953,12 +953,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" } } }, @@ -1033,12 +1033,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" } } }, @@ -1046,12 +1046,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" } } }, @@ -1059,12 +1059,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call2.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call3-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call3-expected.txt index 89111efb1c..9fa5ef92a9 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call3-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call3-expected.txt @@ -771,12 +771,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" } } }, @@ -797,12 +797,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" } } }, @@ -877,12 +877,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" } } }, @@ -890,12 +890,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" } } }, @@ -903,12 +903,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call3.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call4-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call4-expected.txt index 392a44864a..ec2d94e349 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call4-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call4-expected.txt @@ -771,12 +771,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" } } }, @@ -784,12 +784,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" } } }, @@ -797,12 +797,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" } } }, @@ -877,12 +877,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" } } }, @@ -890,12 +890,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" } } }, @@ -903,12 +903,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call4.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call5-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call5-expected.txt index 39628d2def..3df9383402 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call5-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call5-expected.txt @@ -991,12 +991,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" } } }, @@ -1004,12 +1004,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" } } }, @@ -1017,12 +1017,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" } } }, @@ -1097,12 +1097,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" } } }, @@ -1110,12 +1110,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" } } }, @@ -1123,12 +1123,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call5.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call6-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call6-expected.txt index 9da14f69eb..5c7aeb1732 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call6-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call6-expected.txt @@ -1070,12 +1070,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" } } }, @@ -1083,12 +1083,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" } } }, @@ -1096,12 +1096,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" } } }, @@ -1176,12 +1176,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" } } }, @@ -1189,12 +1189,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" } } }, @@ -1202,12 +1202,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call6.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call7-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call7-expected.txt index cbd58d6eb9..a7ec943031 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call7-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call7-expected.txt @@ -191,12 +191,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" } } }, @@ -204,12 +204,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" } } }, @@ -217,12 +217,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" } } }, @@ -297,12 +297,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" } } }, @@ -310,12 +310,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" } } }, @@ -323,12 +323,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call7.ets" } } }, diff --git a/ets2panda/test/parser/ets/test-type-alias-call8-expected.txt b/ets2panda/test/parser/ets/test-type-alias-call8-expected.txt index e8be79828e..1a69254b09 100644 --- a/ets2panda/test/parser/ets/test-type-alias-call8-expected.txt +++ b/ets2panda/test/parser/ets/test-type-alias-call8-expected.txt @@ -740,12 +740,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" } } }, @@ -753,12 +753,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" } } }, @@ -766,12 +766,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" } } }, @@ -846,12 +846,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" } } }, @@ -859,12 +859,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" } } }, @@ -872,12 +872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test-type-alias-call8.ets" } } }, diff --git a/ets2panda/test/parser/ets/test_interface-expected.txt b/ets2panda/test/parser/ets/test_interface-expected.txt index 2661e891fd..7c814e2216 100644 --- a/ets2panda/test/parser/ets/test_interface-expected.txt +++ b/ets2panda/test/parser/ets/test_interface-expected.txt @@ -1062,12 +1062,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" } } }, @@ -1075,12 +1075,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" } } }, @@ -1088,12 +1088,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" } } }, @@ -1168,12 +1168,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" } } }, @@ -1181,12 +1181,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" } } }, @@ -1194,12 +1194,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_interface.ets" } } }, diff --git a/ets2panda/test/parser/ets/test_jsvalue-expected.txt b/ets2panda/test/parser/ets/test_jsvalue-expected.txt index 55691eb571..11a038c823 100644 --- a/ets2panda/test/parser/ets/test_jsvalue-expected.txt +++ b/ets2panda/test/parser/ets/test_jsvalue-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_jsvalue.ets" } } }, diff --git a/ets2panda/test/parser/ets/test_type_alias6-expected.txt b/ets2panda/test/parser/ets/test_type_alias6-expected.txt index 3714ac94d3..417fe11ce0 100644 --- a/ets2panda/test/parser/ets/test_type_alias6-expected.txt +++ b/ets2panda/test/parser/ets/test_type_alias6-expected.txt @@ -127,12 +127,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias6.ets" } } }, @@ -140,12 +140,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias6.ets" } } }, @@ -153,12 +153,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias6.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias6.ets" } } }, @@ -296,40 +296,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "test_type_alias6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 13, + "program": "test_type_alias6.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "test_type_alias6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 13, + "program": "test_type_alias6.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 5, + "program": "test_type_alias6.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 13, + "program": "test_type_alias6.ets" } } }, @@ -337,13 +337,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 17, + "column": 5, "program": "test_type_alias6.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 13, "program": "test_type_alias6.ets" } } diff --git a/ets2panda/test/parser/ets/test_type_alias7-expected.txt b/ets2panda/test/parser/ets/test_type_alias7-expected.txt index c573847b4c..c3e0eb220e 100644 --- a/ets2panda/test/parser/ets/test_type_alias7-expected.txt +++ b/ets2panda/test/parser/ets/test_type_alias7-expected.txt @@ -127,12 +127,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" } } }, @@ -140,12 +140,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" } } }, @@ -153,12 +153,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" } } }, @@ -233,12 +233,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" } } }, @@ -246,12 +246,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" } } }, @@ -259,12 +259,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias7.ets" } } }, diff --git a/ets2panda/test/parser/ets/test_type_alias8-expected.txt b/ets2panda/test/parser/ets/test_type_alias8-expected.txt index 9419cab876..d9f05d631b 100644 --- a/ets2panda/test/parser/ets/test_type_alias8-expected.txt +++ b/ets2panda/test/parser/ets/test_type_alias8-expected.txt @@ -159,12 +159,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias8.ets" } } }, @@ -172,12 +172,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias8.ets" } } }, @@ -185,12 +185,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias8.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias8.ets" } } }, diff --git a/ets2panda/test/parser/ets/test_type_alias9-expected.txt b/ets2panda/test/parser/ets/test_type_alias9-expected.txt index 03175a1639..f400a94374 100644 --- a/ets2panda/test/parser/ets/test_type_alias9-expected.txt +++ b/ets2panda/test/parser/ets/test_type_alias9-expected.txt @@ -302,12 +302,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias9.ets" } } }, @@ -315,12 +315,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias9.ets" } } }, @@ -328,12 +328,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias9.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "test_type_alias9.ets" } } }, @@ -666,40 +666,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "test_type_alias9.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 51, + "program": "test_type_alias9.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "test_type_alias9.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 51, + "program": "test_type_alias9.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 19, + "column": 5, + "program": "test_type_alias9.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 51, + "program": "test_type_alias9.ets" } } }, @@ -707,13 +707,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 19, + "column": 5, "program": "test_type_alias9.ets" }, "end": { - "line": 1, - "column": 1, + "line": 20, + "column": 51, "program": "test_type_alias9.ets" } } diff --git a/ets2panda/test/parser/ets/this_callee-expected.txt b/ets2panda/test/parser/ets/this_callee-expected.txt index c457dda06c..73f868f452 100644 --- a/ets2panda/test/parser/ets/this_callee-expected.txt +++ b/ets2panda/test/parser/ets/this_callee-expected.txt @@ -1332,12 +1332,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" } } }, @@ -1345,12 +1345,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" } } }, @@ -1358,12 +1358,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" } } }, @@ -1438,12 +1438,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" } } }, @@ -1451,12 +1451,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" } } }, @@ -1464,12 +1464,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_callee.ets" } } }, diff --git a/ets2panda/test/parser/ets/this_cmp_object-expected.txt b/ets2panda/test/parser/ets/this_cmp_object-expected.txt index d770e9b0ce..a4284a90a5 100644 --- a/ets2panda/test/parser/ets/this_cmp_object-expected.txt +++ b/ets2panda/test/parser/ets/this_cmp_object-expected.txt @@ -596,12 +596,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" } } }, @@ -609,12 +609,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" } } }, @@ -622,12 +622,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" } } }, @@ -702,12 +702,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" } } }, @@ -715,12 +715,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" } } }, @@ -728,12 +728,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_cmp_object.ets" } } }, diff --git a/ets2panda/test/parser/ets/this_equality-expected.txt b/ets2panda/test/parser/ets/this_equality-expected.txt index 282156505c..db64c6fc35 100644 --- a/ets2panda/test/parser/ets/this_equality-expected.txt +++ b/ets2panda/test/parser/ets/this_equality-expected.txt @@ -498,12 +498,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" } } }, @@ -511,12 +511,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" } } }, @@ -524,12 +524,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" } } }, @@ -604,12 +604,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" } } }, @@ -617,12 +617,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" } } }, @@ -630,12 +630,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_equality.ets" } } }, diff --git a/ets2panda/test/parser/ets/this_expression-expected.txt b/ets2panda/test/parser/ets/this_expression-expected.txt index 2dad6ed7aa..c2bb90c818 100644 --- a/ets2panda/test/parser/ets/this_expression-expected.txt +++ b/ets2panda/test/parser/ets/this_expression-expected.txt @@ -455,12 +455,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" } } }, @@ -468,12 +468,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" } } }, @@ -481,12 +481,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" } } }, @@ -561,12 +561,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" } } }, @@ -574,12 +574,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" } } }, @@ -587,12 +587,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_expression.ets" } } }, diff --git a/ets2panda/test/parser/ets/this_type_class_method_return_valid-expected.txt b/ets2panda/test/parser/ets/this_type_class_method_return_valid-expected.txt index 09196a9800..432afbf6b0 100644 --- a/ets2panda/test/parser/ets/this_type_class_method_return_valid-expected.txt +++ b/ets2panda/test/parser/ets/this_type_class_method_return_valid-expected.txt @@ -435,12 +435,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" } } }, @@ -448,12 +448,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" } } }, @@ -461,12 +461,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" } } }, @@ -541,12 +541,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" } } }, @@ -554,12 +554,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" } } }, @@ -567,12 +567,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "this_type_class_method_return_valid.ets" } } }, diff --git a/ets2panda/test/parser/ets/throwsRethrowsAsVariables-expected.txt b/ets2panda/test/parser/ets/throwsRethrowsAsVariables-expected.txt index 3e02fd2143..1279b59d4f 100644 --- a/ets2panda/test/parser/ets/throwsRethrowsAsVariables-expected.txt +++ b/ets2panda/test/parser/ets/throwsRethrowsAsVariables-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwsRethrowsAsVariables.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwsRethrowsAsVariables.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwsRethrowsAsVariables.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwsRethrowsAsVariables.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "throwsRethrowsAsVariables.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "throwsRethrowsAsVariables.ets" } } }, @@ -313,40 +313,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "throwsRethrowsAsVariables.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 17, + "program": "throwsRethrowsAsVariables.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "throwsRethrowsAsVariables.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 17, + "program": "throwsRethrowsAsVariables.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "throwsRethrowsAsVariables.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 17, + "column": 17, + "program": "throwsRethrowsAsVariables.ets" } } }, @@ -354,13 +354,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "throwsRethrowsAsVariables.ets" }, "end": { - "line": 1, - "column": 1, + "line": 17, + "column": 17, "program": "throwsRethrowsAsVariables.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body-expected.txt index d48d221b31..7ec271f224 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body.ets" } } }, @@ -462,8 +462,8 @@ "program": "trailing_lambda_define_lambda_in_body.ets" }, "end": { - "line": 21, - "column": 10, + "line": 26, + "column": 6, "program": "trailing_lambda_define_lambda_in_body.ets" } } @@ -475,8 +475,8 @@ "program": "trailing_lambda_define_lambda_in_body.ets" }, "end": { - "line": 21, - "column": 10, + "line": 26, + "column": 6, "program": "trailing_lambda_define_lambda_in_body.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body_capture_variable-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body_capture_variable-expected.txt index b39d9d47b3..c8692d99a3 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body_capture_variable-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_define_lambda_in_body_capture_variable-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" } } }, @@ -462,8 +462,8 @@ "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" }, "end": { - "line": 21, - "column": 10, + "line": 27, + "column": 6, "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" } } @@ -475,8 +475,8 @@ "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" }, "end": { - "line": 21, - "column": 10, + "line": 27, + "column": 6, "program": "trailing_lambda_define_lambda_in_body_capture_variable.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload-expected.txt index c4d7a62427..de78229a7f 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" } } }, @@ -186,12 +186,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" } } }, @@ -199,12 +199,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" } } }, @@ -212,12 +212,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload.ets" } } }, @@ -822,8 +822,8 @@ "program": "trailing_lambda_overload.ets" }, "end": { - "line": 26, - "column": 19, + "line": 28, + "column": 6, "program": "trailing_lambda_overload.ets" } } @@ -835,8 +835,8 @@ "program": "trailing_lambda_overload.ets" }, "end": { - "line": 26, - "column": 19, + "line": 28, + "column": 6, "program": "trailing_lambda_overload.ets" } } @@ -850,8 +850,8 @@ "program": "trailing_lambda_overload.ets" }, "end": { - "line": 26, - "column": 19, + "line": 28, + "column": 6, "program": "trailing_lambda_overload.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload_1-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload_1-expected.txt index 16492ab381..b5301d3398 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload_1-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_overload_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_overload_1.ets" } } }, @@ -844,8 +844,8 @@ "program": "trailing_lambda_overload_1.ets" }, "end": { - "line": 25, - "column": 22, + "line": 28, + "column": 6, "program": "trailing_lambda_overload_1.ets" } } @@ -857,8 +857,8 @@ "program": "trailing_lambda_overload_1.ets" }, "end": { - "line": 25, - "column": 22, + "line": 28, + "column": 6, "program": "trailing_lambda_overload_1.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_transform_trailing_block-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_transform_trailing_block-expected.txt index d5582cd45c..752033be59 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_transform_trailing_block-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_transform_trailing_block-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_transform_trailing_block.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_transform_trailing_block.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_transform_trailing_block.ets" } } }, @@ -478,8 +478,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 23, - "column": 8, + "line": 25, + "column": 6, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -491,8 +491,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 23, - "column": 8, + "line": 25, + "column": 6, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -527,8 +527,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 27, - "column": 8, + "line": 30, + "column": 6, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -540,8 +540,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 27, - "column": 8, + "line": 30, + "column": 6, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -612,7 +612,7 @@ }, "end": { "line": 33, - "column": 21, + "column": 24, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -625,7 +625,7 @@ }, "end": { "line": 33, - "column": 21, + "column": 24, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -640,7 +640,7 @@ }, "end": { "line": 33, - "column": 21, + "column": 24, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -710,8 +710,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 35, - "column": 21, + "line": 36, + "column": 7, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -723,8 +723,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 35, - "column": 21, + "line": 36, + "column": 7, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -738,8 +738,8 @@ "program": "trailing_lambda_transform_trailing_block.ets" }, "end": { - "line": 35, - "column": 21, + "line": 36, + "column": 7, "program": "trailing_lambda_transform_trailing_block.ets" } } @@ -845,7 +845,7 @@ }, "end": { "line": 39, - "column": 28, + "column": 30, "program": "trailing_lambda_transform_trailing_block.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_type_alias-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_type_alias-expected.txt index 06a0e752e6..975d122ed4 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_type_alias-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_type_alias-expected.txt @@ -143,12 +143,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_type_alias.ets" } } }, @@ -156,12 +156,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_type_alias.ets" } } }, @@ -169,12 +169,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_type_alias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_type_alias.ets" } } }, @@ -542,7 +542,7 @@ }, "end": { "line": 24, - "column": 10, + "column": 14, "program": "trailing_lambda_type_alias.ets" } } diff --git a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_with_throw-expected.txt b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_with_throw-expected.txt index edeeb7a594..5b56462570 100644 --- a/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_with_throw-expected.txt +++ b/ets2panda/test/parser/ets/trailing_lambda_tests/trailing_lambda_with_throw-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_with_throw.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_with_throw.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_with_throw.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_with_throw.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_with_throw.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "trailing_lambda_with_throw.ets" } } }, @@ -553,8 +553,8 @@ "program": "trailing_lambda_with_throw.ets" }, "end": { - "line": 23, - "column": 10, + "line": 25, + "column": 6, "program": "trailing_lambda_with_throw.ets" } } @@ -566,8 +566,8 @@ "program": "trailing_lambda_with_throw.ets" }, "end": { - "line": 23, - "column": 10, + "line": 25, + "column": 6, "program": "trailing_lambda_with_throw.ets" } } @@ -603,7 +603,7 @@ }, "end": { "line": 27, - "column": 10, + "column": 13, "program": "trailing_lambda_with_throw.ets" } } @@ -616,7 +616,7 @@ }, "end": { "line": 27, - "column": 10, + "column": 13, "program": "trailing_lambda_with_throw.ets" } } @@ -651,8 +651,8 @@ "program": "trailing_lambda_with_throw.ets" }, "end": { - "line": 29, - "column": 11, + "line": 31, + "column": 6, "program": "trailing_lambda_with_throw.ets" } } @@ -664,8 +664,8 @@ "program": "trailing_lambda_with_throw.ets" }, "end": { - "line": 29, - "column": 11, + "line": 31, + "column": 6, "program": "trailing_lambda_with_throw.ets" } } @@ -701,7 +701,7 @@ }, "end": { "line": 33, - "column": 11, + "column": 14, "program": "trailing_lambda_with_throw.ets" } } @@ -714,7 +714,7 @@ }, "end": { "line": 33, - "column": 11, + "column": 14, "program": "trailing_lambda_with_throw.ets" } } diff --git a/ets2panda/test/parser/ets/tryFinallyBlockOnly-expected.txt b/ets2panda/test/parser/ets/tryFinallyBlockOnly-expected.txt index efc7059279..f7fc6d09ba 100644 --- a/ets2panda/test/parser/ets/tryFinallyBlockOnly-expected.txt +++ b/ets2panda/test/parser/ets/tryFinallyBlockOnly-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryFinallyBlockOnly.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryFinallyBlockOnly.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryFinallyBlockOnly.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryFinallyBlockOnly.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tryFinallyBlockOnly.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tryFinallyBlockOnly.ets" } } }, diff --git a/ets2panda/test/parser/ets/tupleAsTypeParam1-expected.txt b/ets2panda/test/parser/ets/tupleAsTypeParam1-expected.txt index 7498cb54ad..9d0c979f2c 100644 --- a/ets2panda/test/parser/ets/tupleAsTypeParam1-expected.txt +++ b/ets2panda/test/parser/ets/tupleAsTypeParam1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam1.ets" } } }, diff --git a/ets2panda/test/parser/ets/tupleAsTypeParam2-expected.txt b/ets2panda/test/parser/ets/tupleAsTypeParam2-expected.txt index 3df264a32d..0b6ee5fa97 100644 --- a/ets2panda/test/parser/ets/tupleAsTypeParam2-expected.txt +++ b/ets2panda/test/parser/ets/tupleAsTypeParam2-expected.txt @@ -678,12 +678,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam2.ets" } } }, @@ -691,12 +691,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam2.ets" } } }, @@ -704,12 +704,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleAsTypeParam2.ets" } } }, diff --git a/ets2panda/test/parser/ets/tupleIndexWithNumbers-expected.txt b/ets2panda/test/parser/ets/tupleIndexWithNumbers-expected.txt index 6934a43364..f8561bc609 100644 --- a/ets2panda/test/parser/ets/tupleIndexWithNumbers-expected.txt +++ b/ets2panda/test/parser/ets/tupleIndexWithNumbers-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleIndexWithNumbers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleIndexWithNumbers.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleIndexWithNumbers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleIndexWithNumbers.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "tupleIndexWithNumbers.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "tupleIndexWithNumbers.ets" } } }, diff --git a/ets2panda/test/parser/ets/type_alias_1-expected.txt b/ets2panda/test/parser/ets/type_alias_1-expected.txt index 15681894ec..454187bc1b 100644 --- a/ets2panda/test/parser/ets/type_alias_1-expected.txt +++ b/ets2panda/test/parser/ets/type_alias_1-expected.txt @@ -255,12 +255,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" } } }, @@ -268,12 +268,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" } } }, @@ -281,12 +281,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" } } }, @@ -361,12 +361,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" } } }, @@ -374,12 +374,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" } } }, @@ -387,12 +387,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/type_alias_2-expected.txt b/ets2panda/test/parser/ets/type_alias_2-expected.txt index 15825e7d91..618e2198f2 100644 --- a/ets2panda/test/parser/ets/type_alias_2-expected.txt +++ b/ets2panda/test/parser/ets/type_alias_2-expected.txt @@ -532,12 +532,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" } } }, @@ -545,12 +545,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" } } }, @@ -558,12 +558,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" } } }, @@ -638,12 +638,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" } } }, @@ -651,12 +651,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" } } }, @@ -664,12 +664,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_alias_2.ets" } } }, diff --git a/ets2panda/test/parser/ets/type_cast-expected.txt b/ets2panda/test/parser/ets/type_cast-expected.txt index d75a72aa64..18fe8c37da 100644 --- a/ets2panda/test/parser/ets/type_cast-expected.txt +++ b/ets2panda/test/parser/ets/type_cast-expected.txt @@ -913,12 +913,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" } } }, @@ -926,12 +926,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" } } }, @@ -939,12 +939,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" } } }, @@ -1019,12 +1019,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" } } }, @@ -1032,12 +1032,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" } } }, @@ -1045,12 +1045,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_cast.ets" } } }, diff --git a/ets2panda/test/parser/ets/type_variance1-expected.txt b/ets2panda/test/parser/ets/type_variance1-expected.txt index d129a48009..ac099eb7c1 100644 --- a/ets2panda/test/parser/ets/type_variance1-expected.txt +++ b/ets2panda/test/parser/ets/type_variance1-expected.txt @@ -2062,12 +2062,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" } } }, @@ -2075,12 +2075,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" } } }, @@ -2088,12 +2088,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" } } }, @@ -2168,12 +2168,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" } } }, @@ -2181,12 +2181,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" } } }, @@ -2194,12 +2194,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "type_variance1.ets" } } }, diff --git a/ets2panda/test/parser/ets/unary_op-expected.txt b/ets2panda/test/parser/ets/unary_op-expected.txt index 6671ec78a8..bf769e37b6 100644 --- a/ets2panda/test/parser/ets/unary_op-expected.txt +++ b/ets2panda/test/parser/ets/unary_op-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_op.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_op.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_op.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_op.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_op.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_op.ets" } } }, @@ -851,40 +851,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "unary_op.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 25, + "column": 11, + "program": "unary_op.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "unary_op.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 25, + "column": 11, + "program": "unary_op.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 16, + "column": 5, + "program": "unary_op.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 25, + "column": 11, + "program": "unary_op.ets" } } }, @@ -892,13 +892,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 16, + "column": 5, "program": "unary_op.ets" }, "end": { - "line": 1, - "column": 1, + "line": 25, + "column": 11, "program": "unary_op.ets" } } diff --git a/ets2panda/test/parser/ets/unary_operations-expected.txt b/ets2panda/test/parser/ets/unary_operations-expected.txt index a9ba27db68..a11ae01da3 100644 --- a/ets2panda/test/parser/ets/unary_operations-expected.txt +++ b/ets2panda/test/parser/ets/unary_operations-expected.txt @@ -1345,12 +1345,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" } } }, @@ -1358,12 +1358,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" } } }, @@ -1371,12 +1371,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" } } }, @@ -1451,12 +1451,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" } } }, @@ -1464,12 +1464,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" } } }, @@ -1477,12 +1477,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "unary_operations.ets" } } }, diff --git a/ets2panda/test/parser/ets/undefinedNullObjectTypeAnnotation-expected.txt b/ets2panda/test/parser/ets/undefinedNullObjectTypeAnnotation-expected.txt index 78996b58f8..40880a3dc8 100644 --- a/ets2panda/test/parser/ets/undefinedNullObjectTypeAnnotation-expected.txt +++ b/ets2panda/test/parser/ets/undefinedNullObjectTypeAnnotation-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullObjectTypeAnnotation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullObjectTypeAnnotation.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullObjectTypeAnnotation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullObjectTypeAnnotation.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullObjectTypeAnnotation.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullObjectTypeAnnotation.ets" } } }, diff --git a/ets2panda/test/parser/ets/undefinedNullTypeAlias-expected.txt b/ets2panda/test/parser/ets/undefinedNullTypeAlias-expected.txt index 4b3e2ea068..e4f2eb5dad 100644 --- a/ets2panda/test/parser/ets/undefinedNullTypeAlias-expected.txt +++ b/ets2panda/test/parser/ets/undefinedNullTypeAlias-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullTypeAlias.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullTypeAlias.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullTypeAlias.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "undefinedNullTypeAlias.ets" } } }, diff --git a/ets2panda/test/parser/ets/union_lowering_common_property-expected.txt b/ets2panda/test/parser/ets/union_lowering_common_property-expected.txt index e8fc70c1a2..c44d4ec551 100644 --- a/ets2panda/test/parser/ets/union_lowering_common_property-expected.txt +++ b/ets2panda/test/parser/ets/union_lowering_common_property-expected.txt @@ -739,12 +739,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" } } }, @@ -752,12 +752,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" } } }, @@ -765,12 +765,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" } } }, @@ -845,12 +845,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" } } }, @@ -858,12 +858,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" } } }, @@ -871,12 +871,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "union_lowering_common_property.ets" } } }, diff --git a/ets2panda/test/parser/ets/user_defined_22-expected.txt b/ets2panda/test/parser/ets/user_defined_22-expected.txt index 51cd61406c..75ff8d5431 100644 --- a/ets2panda/test/parser/ets/user_defined_22-expected.txt +++ b/ets2panda/test/parser/ets/user_defined_22-expected.txt @@ -417,12 +417,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "user_defined_22.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "user_defined_22.ets" } } }, @@ -430,12 +430,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "user_defined_22.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "user_defined_22.ets" } } }, @@ -443,12 +443,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "user_defined_22.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "user_defined_22.ets" } } }, @@ -763,40 +763,40 @@ ], "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "user_defined_22.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 14, + "program": "user_defined_22.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "user_defined_22.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 14, + "program": "user_defined_22.ets" } } }, "loc": { "start": { - "line": 1, - "column": 1, - "program": null + "line": 20, + "column": 5, + "program": "user_defined_22.ets" }, "end": { - "line": 1, - "column": 1, - "program": null + "line": 22, + "column": 14, + "program": "user_defined_22.ets" } } }, @@ -804,13 +804,13 @@ "decorators": [], "loc": { "start": { - "line": 1, - "column": 1, + "line": 20, + "column": 5, "program": "user_defined_22.ets" }, "end": { - "line": 1, - "column": 1, + "line": 22, + "column": 14, "program": "user_defined_22.ets" } } diff --git a/ets2panda/test/parser/ets/var_declare-expected.txt b/ets2panda/test/parser/ets/var_declare-expected.txt index 7b2fb7d830..e78e94dbf3 100644 --- a/ets2panda/test/parser/ets/var_declare-expected.txt +++ b/ets2panda/test/parser/ets/var_declare-expected.txt @@ -859,12 +859,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" } } }, @@ -872,12 +872,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" } } }, @@ -885,12 +885,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" } } }, @@ -965,12 +965,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" } } }, @@ -978,12 +978,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" } } }, @@ -991,12 +991,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "var_declare.ets" } } }, diff --git a/ets2panda/test/parser/ets/variable_throw_function_1-expected.txt b/ets2panda/test/parser/ets/variable_throw_function_1-expected.txt index 68ebafcd7a..d03f14a068 100644 --- a/ets2panda/test/parser/ets/variable_throw_function_1-expected.txt +++ b/ets2panda/test/parser/ets/variable_throw_function_1-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "variable_throw_function_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "variable_throw_function_1.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "variable_throw_function_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "variable_throw_function_1.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "variable_throw_function_1.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "variable_throw_function_1.ets" } } }, diff --git a/ets2panda/test/parser/ets/void-expected.txt b/ets2panda/test/parser/ets/void-expected.txt index 45431713d7..0547d89c74 100644 --- a/ets2panda/test/parser/ets/void-expected.txt +++ b/ets2panda/test/parser/ets/void-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "void.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "void.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "void.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "void.ets" } } }, diff --git a/ets2panda/test/parser/ets/voidAsTypeArg-expected.txt b/ets2panda/test/parser/ets/voidAsTypeArg-expected.txt index 8b60ada366..2da78e8ed5 100644 --- a/ets2panda/test/parser/ets/voidAsTypeArg-expected.txt +++ b/ets2panda/test/parser/ets/voidAsTypeArg-expected.txt @@ -80,12 +80,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "voidAsTypeArg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "voidAsTypeArg.ets" } } }, @@ -93,12 +93,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "voidAsTypeArg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "voidAsTypeArg.ets" } } }, @@ -106,12 +106,12 @@ "start": { "line": 1, "column": 1, - "program": null + "program": "voidAsTypeArg.ets" }, "end": { "line": 1, "column": 1, - "program": null + "program": "voidAsTypeArg.ets" } } }, diff --git a/ets2panda/test/unit/lowerings/top_level_statements.cpp b/ets2panda/test/unit/lowerings/top_level_statements.cpp index c7fedb4621..f942fdfea7 100644 --- a/ets2panda/test/unit/lowerings/top_level_statements.cpp +++ b/ets2panda/test/unit/lowerings/top_level_statements.cpp @@ -154,4 +154,29 @@ TEST_F(LoweringTest, TestTopLevelStmtsExportedEnum) } } +TEST_F(LoweringTest, TestTrailingLambdaSourceRange) +{ + char const *text = R"( + function foo(ff: ()=>void) {} + function testfoo() {} + foo() { + testfoo() + } + )"; + + CONTEXT(ES2PANDA_STATE_ASM_GENERATED, text) + { + const auto *const ast = GetAst(); + constexpr uint32_t EXPECTED_STARTLINE = 4; + constexpr uint32_t EXPECTED_ENDLINE = 4; + auto *callExpr = ast->FindChild([](ir::AstNode *child) { + return child->IsCallExpression() && child->AsCallExpression()->Callee()->IsIdentifier() && + child->AsCallExpression()->Callee()->AsIdentifier()->Name().Is("testfoo"); + }); + ASSERT(callExpr != nullptr); + ASSERT_EQ(callExpr->Start().line, EXPECTED_STARTLINE); + ASSERT_EQ(callExpr->End().line, EXPECTED_ENDLINE); + } +} + } // namespace ark::es2panda diff --git a/ets2panda/test/unit/lsp/get_touching_token_test.cpp b/ets2panda/test/unit/lsp/get_touching_token_test.cpp index c95412b50c..a25b3de2a4 100644 --- a/ets2panda/test/unit/lsp/get_touching_token_test.cpp +++ b/ets2panda/test/unit/lsp/get_touching_token_test.cpp @@ -67,7 +67,9 @@ TEST_F(LSPAPITests, GetTouchingToken3) size_t const offset = 51; auto result = ark::es2panda::lsp::GetTouchingToken(ctx, offset, true); auto ast = GetAstFromContext(ctx); - auto expectedNode = ast->FindChild([](ark::es2panda::ir::AstNode *node) { return node->IsExpressionStatement(); }); + auto expectedNode = ast->FindChild([](ark::es2panda::ir::AstNode *node) { + return node->IsMethodDefinition() && node->AsMethodDefinition()->Key()->AsIdentifier()->Name().Is("_$init$_"); + }); ASSERT_EQ(result->DumpJSON(), expectedNode->DumpJSON()); ASSERT_EQ(result->Start().index, expectedNode->Start().index); ASSERT_EQ(result->End().index, expectedNode->End().index); -- Gitee