package maldoca

Get desktop application:
View/edit binary Protocol Buffers messages

Top-level AST definition.

• optional string lang_name = 1

  The shortened language name. E.g. "js"

• repeated EnumDefPb enums = 2

• repeated NodeDefPb nodes = 3

• repeated UnionTypePb union_types = 4

Babel AST in the form of JSON string.

Used in: JsReprPb

• optional string value = 1

  The actual string.

• optional bool string_literals_base64_encoded = 2

  Whether string literals have been base64-encoded.

• optional BabelScopes scopes = 3

Used in: BabelScope

• optional BabelBinding.Kind kind = 1

• optional string name = 2

Used in: BabelBinding

• KIND_UNKNOWN = 0

• KIND_VAR = 1

• KIND_LET = 2

• KIND_CONST = 3

• KIND_MODULE = 4

• KIND_HOISTED = 5

• KIND_PARAM = 6

• KIND_LOCAL = 7

Used in: BabelErrors, BabelGenerateResponse, BabelParseResponse

• optional string name = 1

• optional string message = 2

• optional PositionPb loc = 3

• repeated BabelError errors = 1

Options for the Babel code generator.

Used in: JsAstStringToSourceConfig

• optional bool include_comments = 1

  Whether comments are kept in the generated source.

• optional bool compact = 2

  Whether to minify the generated source.

• optional bool source_maps = 3

  Whether to generate source maps.

Used in: BabelRequest

• optional bool include_comments = 1

  Should comments be included in output?

• optional bool base64_decode_string_literals = 2

  Whether we should base64-decode string literals.

• optional bool compact = 3

  Whether to minify the generated source.

• optional bool source_maps = 4

  Whether to generate source maps.

Used in: BabelResponse

• optional BabelError error = 1

  Babel throws exceptions if the provided AST is invalid.

• optional string source_map = 2

Options for the Babel parser.

Used in: BabelRequest, JsSourceToAstStringConfig

• optional bool error_recovery = 1

  Enables error recovery in the parser. Note that error recovery is only available since babel_parser 7.7.0, so only v8_babel supports it, not sandboxed_nodejs_babel. https://babeljs.io/blog/2019/11/05/7.7.0

• optional bool replace_invalid_surrogate_pairs = 2

  Replaces invalid surrogate pairs with double question mark symbol (\UFFFD). JavaScript strings are represented as UTF-16. Surrogate pairs are characters represented by two 16-bit numbers. Each surrogate pair must start with a high surrogate (in [U+D800, U+DBFF]), and end with a low surrogate (in [U+DC00 to U+DFFF]). A single surrogate, or a pair that starts with a low surrogate and ends with a high surrogate is considered invalid. If the UTF-16 character sequence is invalid, then nlohmann::json fails to parse the JSON string. This flag enables the feature that converts any surrogate character that is not part of a valid surrogate pair into '�' (\UFFFD). Example: "abc\UD834\UDF06" -> "abc𝌆" (valid surrogate pair) "abc\UD834" -> "abc�" (lone surrogate) "abc\UDF06\UD834" -> "abc��" (invalid surrogate pair) See b/235090893 for context. replace_invalid_surrogate_pairs == false: ``` Node { type: 'StringLiteral', extra: { rawValue: '\udf06\ud834', raw: '"\\udf06\\ud834"' }, value: '\udf06\ud834' } ``` replace_invalid_surrogate_pairs == true: ``` Node { type: 'StringLiteral', extra: { rawValue: '\ufffd', raw: '"\\udf06\\ud834"' }, value: '\ufffd' } ```

• optional bool base64_encode_string_literals = 5

  Whether string literals will be base64-encoded in the AST. base64_encode_string_literals == false: ``` Node { type: 'StringLiteral', extra: { rawValue: 'A', raw: '"\u0041"' }, value: 'A' } ``` base64_encode_string_literals == true: ``` Node { type: 'StringLiteral', extra: { rawValue: 'YQ==', raw: '"\u0041"' }, value: 'YQ==' } ```

• optional BabelParseRequest.SourceType source_type = 3

• optional BabelParseRequest.StrictMode strict_mode = 4

• optional bool compute_scopes = 6

  Whether to add scope information in the AST. If true: - A separate Scopes proto will be returned - Each AST node will have an additional scopeUid field, specifying which scope it belongs to

The mode in which source code should be parsed. "unspecified" defaults to "script". "unambiguous" will make @babel/parser attempt to guess, based on the presence of ES6 import or export statements. Files with ES6 imports and exports are considered "module" and are otherwise "script".

Used in: BabelParseRequest

• SOURCE_TYPE_UNSPECIFIED = 0

• SOURCE_TYPE_SCRIPT = 1

• SOURCE_TYPE_MODULE = 2

• SOURCE_TYPE_UNAMBIGUOUS = 3

Should the parser work in strict mode (i.e. throw more errors). According to Babel's comment, if strictMode is undefined, then it depends on whether sourceType is 'module'. However, the source code has a bug such that even if strictMode is true, the parser still depends on sourceType. Implementation: +------------------------+--------------------------+ | | strictMode | | +-----------+------+-------+ | | undefined | true | false | +---------------+--------+-----------+------+-------+ | source type | module | ✓ | | | (specified +--------+------------------+ ✗ | | or inferred) | script | ✗ | | +---------------+--------+------------------+-------+ Specification: +------------------------+--------------------------+ | | strictMode | | +-----------+------+-------+ | | undefined | true | false | +---------------+--------+-----------+------+-------+ | source type | module | ✓ | | | | (specified +--------+-----------+ ✓ | ✗ | | or inferred) | script | ✗ | | | +---------------+--------+-----------+------+-------+

Used in: BabelParseRequest

• STRICT_MODE_UNSPECIFIED = 0

• STRICT_MODE_YES = 1

• STRICT_MODE_NO = 2

Only contains the errors (if any) in the response. The AST is returned separately.

Used in: BabelResponse

• repeated BabelError errors = 1

  Some errors are recoverable and/or are not severe enough to stop parsing. Currently Babel always throws an exception when parsing fails, so we can have at most one error.

• optional BabelScopes scopes = 2

• oneof kind

  • BabelParseRequest parse = 1

  • BabelGenerateRequest generate = 2

• oneof kind

  • BabelParseResponse parse = 1

  • BabelGenerateResponse generate = 2

Used in: BabelScopes

• optional int32 uid = 1

• optional int32 parent_uid = 2

• map<string, BabelBinding> bindings = 3

Used in: BabelAstString, BabelParseResponse

• map<int32, BabelScope> scopes = 1

Used in: NonListTypePb, ScalarTypePb, TypePb

(message has no fields)

Used in: NonListTypePb, ScalarTypePb, TypePb

(message has no fields)

Used in: AstDefPb

• optional string name = 1

• repeated EnumMemberDefPb members = 2

Used in: EnumDefPb

• optional string name = 1

• optional string string_value = 2

Definition of a field in an AST node.

Used in: NodeDefPb

• optional string name = 1

  Name of the field. Must be camelCase.

• optional Optionalness optionalness = 2

  The optionalness of a field - whether it might be null or undefined.

• optional TypePb type = 3

  The type of the field.

• optional FieldKind kind = 4

  The field kind. E.g. LVAL.

• optional bool ignore_in_ir = 5

  Whether the field should be ignored in the IR op. For example, we might want to ignore the source location fields, since MLIR has builtin support for source location. In the AST <-> IR conversion, we need to supply some manually-written code to convert between source location fields and MLIR's source location attributes.

• optional bool enclose_in_region = 6

  Whether the field should be enclosed in a region. For example, if the field is a statement, we should create a nested region and enclose the field in it. Detail: Normally, an argument of an IR op is logically executed before the op itself. For example, consider the following AST: ``` BinaryExpression { operator: "+" left: Identifier { "a" } right: Identifier { "b" } } ``` We can transform it into the following IR: ``` %left = jsir.identifier {"a"} %right = jsir.identifier {"b"} %bin_expr = jsir.binary_expression (%left, %right) ``` We can see that the IR is, in a sense, a post-order traversal of the AST. However, if an AST node has a statement field, we cannot model it in the IR this way. For example, consider the following AST: ``` IfStatement { test: Identifier { "a" } body: SomeSortOfStatement {} } ``` If we are to use the same approach, we would transform it into the following IR: ``` %test = jsir.identifier {"a"} %body = jsir.some_sort_of_statement jsir.if_statement (%test, %body) ``` This is problematic, because: 1. The semantics of the if statement is that `body` might not be executed. However, in this IR it appears that body is always executed. 2. jsir.some_sort_of_statement shouldn't have a return value. However, in this IR it must have one, just for the if_statement to reference the op. Therefore, we need to put body **inside** of the if statement, like this: ``` %test = jsir.identifier {"a"} jsir.if_statement (%test) { jsir.some_sort_of_statement } ``` Therefore, we define `enclose_in_region` to specify that this AST field, when converted to an IR op, should be further enclosed in a region.

========= FieldKind ========= Each field in an AST node has a "kind". This is because different kinds of AST nodes lead to different forms of IR ops. Example: For the assignment expression "x = y", lhs and rhs have the same AST node type: Identifier. AST: ``` AssignmentExpression { lhs: Identifier {"x"} rhs: Identifier {"y"} } ``` However, lhs is an lvalue, but rhs is an rvalue. Therefore, they lower to different IR ops: ``` %lhs = identifier_ref {"x"} %rhs = identifier {"y"} assignment_expression (%lhs, %rhs) ``` We can see that "x" lowers to an "identifier_ref" op, but "y" lowers to an "identifier" op. In order to support this, we need to: - Specify that Assignment::lhs has an "LVAL" kind. - Specify that Assignment::rhs has an "RVAL" kind. - Specify that the Identifier node type can be both LVAL and RVAL.

Used in: FieldDefPb, NodeDefPb, UnionTypePb

• FIELD_KIND_UNSPECIFIED = 0

• FIELD_KIND_ATTR = 1

  This field is an attribute (has builtin type).

• FIELD_KIND_RVAL = 2

  This field is an rvalue expression. If the expression type has an LVAL kind, we need to create an additional "load" op.

• FIELD_KIND_LVAL = 3

  This field is an lvalue expression. The expression type must have an LVAL kind.

• FIELD_KIND_STMT = 4

  This field is a statement.

Used in: NonListTypePb, ScalarTypePb, TypePb

(message has no fields)

Used in: JsAnalysisOutputs

• oneof kind

  • JsAstAnalysisResult ast_analysis = 1

  • JsirAnalysisResult jsir_analysis = 2

• repeated JsAnalysisOutput outputs = 1

Used in: JsAnalysisOutput

• oneof kind

  • JsirAnalysisConfig.DynamicConstantPropagation extract_prelude = 2

    Added by JsAstTransformConfig.ExtractPrelude

Used in: JsConversionConfig

• optional int32 recursion_depth_limit = 1

Used in: JsConversionConfig

• optional BabelGenerateOptions babel_generate_options = 1

• optional google.protobuf.Duration timeout = 2

Used in: JsConversionConfig

(message has no fields)

Used in: JsConversionConfig

(message has no fields)

Used in: JsPassConfig

• oneof kind

  • JsAstTransformConfig.EraseComments erase_comments = 1

  • JsAstTransformConfig.ExtractPrelude extract_prelude = 2

Used in: JsAstTransformConfig

(message has no fields)

Used in: JsAstTransformConfig

• repeated int64 prelude_indices = 1

  The indices of the top-level statements to extract.

Used in: JsPassConfig

• oneof kind

  • JsSourceToAstStringConfig js_source_to_ast_string = 1

    source <=> ast string

  • JsAstStringToSourceConfig js_ast_string_to_source = 2

  • JsAstStringToAstConfig js_ast_string_to_ast = 3

    ast string <=> ast

  • JsAstToAstStringConfig js_ast_to_ast_string = 4

  • JsAstToHirConfig js_ast_to_hir = 5

    ast <=> hir

  • JsHirToAstConfig js_hir_to_ast = 6

Used in: JsConversionConfig

(message has no fields)

Used in: JsPassConfigs

• oneof kind

  • JsConversionConfig conversion = 1

  • JsirAnalysisConfig jsir_analysis = 3

    Analysis

  • JsAstTransformConfig ast_transform = 4

    Transform

  • JsirTransformConfig jsir_transform = 5

• repeated JsPassConfig passes = 1

• oneof kind

  • string js_source = 1

  • BabelAstString babel_ast_string = 2

  • string js_hir = 3

• optional string source_map = 7

Used in: JsConversionConfig

• optional BabelParseRequest babel_parse_request = 1

• optional google.protobuf.Duration timeout = 2

Used in: JsPassConfig

• oneof kind

  ========================================================================= JSIR Dataflow Analyses ========================================================================= The result of a JSIR dataflow analysis contains lattice elements attached to MLIR operations and MLIR values. As a result, it can't be returned in a standalone proto. Here we will just return a string for debugging purposes.

  • JsirAnalysisConfig.ConstantPropagation constant_propagation = 5

  • JsirAnalysisConfig.DynamicConstantPropagation dynamic_constant_propagation = 6

Used in: JsirAnalysisConfig

(message has no fields)

Used in: JsAstAnalysisResult, JsirAnalysisConfig, JsirTransformConfig

• optional string prelude_source = 1

• repeated string prelude_functions = 2

• optional int64 extracted_from_scope_uid = 3

  The scope uid of the scope where the prelude is extracted from. * If the prelude is extracted from the AST, this is the global scope uid of the original AST. * If the prelude is not extracted from the AST, this field is not set. Details: When we use the ExtractPrelude pass to remove the prelude from the AST, the corresponding `BabelScopes` still reflects the original AST, which means the prelude symbols are still in the global scope. Here we store the uid of the global scope in the original AST, so that the dynamic constant propagation analysis can correctly find the prelude symbols. If the prelude is not extracted from the AST, i.e. the prelude is provided by the user, then the prelude symbols are not in the global scope of the AST to be analyzed. In this case, this field is not set.

Used in: JsAnalysisOutput

• oneof kind

  • JsirAnalysisResult.DataFlow constant_propagation = 5

  • JsirAnalysisResult.DynamicConstantPropagation dynamic_constant_propagation = 6

Used in: JsirAnalysisResult, DynamicConstantPropagation

• optional string output = 1

Used in: JsirAnalysisResult

• optional string bindings = 1

  A debug print of the const bindings.

• optional DataFlow data_flow = 2

• repeated DynamicConstantPropagation.ComputedConstant computed_constants = 3

Used in: DynamicConstantPropagation

• optional int64 start_offset = 1

• optional int64 end_offset = 2

• oneof value_kind

  • string string_value = 3

  • double number_value = 4

  • string big_int_value = 5

  • bool bool_value = 6

Used in: JsPassConfig

• oneof kind

  • JsirTransformConfig.ConstantPropagation constant_propagation = 1

  • JsirTransformConfig.MoveNamedFunctions move_named_functions = 3

  • JsirTransformConfig.NormalizeObjectProperties normalize_object_properties = 4

  • JsirTransformConfig.PeelParentheses peel_parentheses = 5

  • JsirTransformConfig.SplitSequenceExpressions split_sequence_expressions = 6

  • JsirTransformConfig.SplitDeclarationStatements split_declaration_statements = 8

  • JsirTransformConfig.RemoveDirectives remove_directives = 7

  • JsirAnalysisConfig.DynamicConstantPropagation dynamic_constant_propagation = 2

  • JsirTransformConfig.DeadCodeElimination dead_code_elimination = 9

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: JsirTransformConfig

(message has no fields)

Used in: TypePb

• optional NonListTypePb element_type = 1

• optional bool element_maybe_null = 2

MLIR traits.

Used in: NodeDefPb

• MLIR_TRAIT_INVALID = 0

• MLIR_TRAIT_PURE = 1

  Pure

• MLIR_TRAIT_ISOLATED_FROM_ABOVE = 2

  IsolatedFromAbove

Definition of an AST node type.

Used in: AstDefPb

• optional string name = 1

  Name of the node. Must be PascalCase. E.g. "BinaryExpression".

• optional string type = 2

  Type kind string. In the JavaScript object version of the AST, a special "type" string represents the kind of the node. interface BinaryExpression <: Expression { type: "BinaryExpression"; <============ This field. operator: BinaryOperator; left: Expression | PrivateName; right: Expression; } The "type" string only has a concrete value in leaf types. interface Expression <: Node { } <======= No "type" value defined. The existence of a concrete "type" value suggests that this is a leaf type.

• repeated string parents = 3

  Parent nodes to inherit from.

• repeated FieldDefPb fields = 4

  Fields defined by this node. Not including fields in parents.

• optional bool should_generate_ir_op = 5

  If true, automatically generate the corresponding op. If false, the op is expected to be manually written.

• repeated FieldKind kinds = 6

  Supported kinds. Each kind leads to a different IR op.

• optional bool has_control_flow = 7

  Whether this op has control flow. If so, we will define a high-level IR op, and a low-level IR op.

• optional string ir_op_name = 8

  [Optional] Custom MLIR op name. By default, each AST node corresponds to an equivalent op or interface: - JsNumericLiteral <=> JsirNumericLiteralOp - JsExpression <=> JsirExpressionOpInterface If a custom op name is specified, then the corresponding MLIR op will not be generated, and its ancestors will not have corresponding interfaces. - JsNumericLiteral <=> mlir::arith::ConstantOp - JsExpression <=> mlir::Value

• optional bool has_fold = 9

  Whether this node has a fold operation

• repeated MlirTrait additional_mlir_traits = 10

  Additional MLIR traits to add to the op definition.

Used in: ListTypePb

• oneof kind

  • BoolTypePb bool = 1

  • Int64TypePb int64 = 2

  • DoubleTypePb double = 3

  • StringTypePb string = 4

  • string enum = 5

  • string class = 6

  • VariantTypePb variant = 7

This is an unfortunate Babel-specific detail. Since Babel's AST is a JSON object, maybe_null and maybe_undefined are different cases. - "field: string | null" This means the field must exist, but could be null. Example: The specification for "AwaitExpression" is this: ``` interface AwaitExpression <: Expression { type: "AwaitExpression"; argument: Expression | null; } ``` In the above example, "argument" is maybe_null, which means that in the JSON object, the entry must exist, but the value can be null: ``` { "type": "AwaitExpression", "argument": null // <---- value is null. } ``` - "field?: string" This means the field might not exist, but if it does, it must be non-null. Example: The specification for "CatchClause" is this: ``` interface CatchClause <: Node { type: "CatchClause"; param?: Pattern; body: BlockStatement; } ``` In the above example, "param" is maybe_undefined, which means that in the JSON object, the entry might not exist at all: ``` { "type": "CatchClause", // <---- "param" doesn't exist. "body": { ... } } ``` However, it appears that in Babel's AST, there is no field that is both maybe_null and maybe_undefined (in other words, there is no such thing as "field?: string | null"). Therefore, both cases are represented as "std::optional<std::string>".

Used in: FieldDefPb

• OPTIONALNESS_UNSPECIFIED = 0

  No semantic meaning. go/protodosdonts#do-include-an-unspecified-value-in-an-enum

• OPTIONALNESS_REQUIRED = 1

  Field must exist and be non-null.

• OPTIONALNESS_MAYBE_NULL = 2

  Field must exist, but might be null.

• OPTIONALNESS_MAYBE_UNDEFINED = 3

  Field might not exist, but when it exists, it must be non-null.

Used in: BabelError

• optional int64 line = 1

• optional int64 column = 2

Used in: VariantTypePb

• oneof kind

  • BoolTypePb bool = 1

  • Int64TypePb int64 = 2

  • DoubleTypePb double = 3

  • StringTypePb string = 4

  • string enum = 5

  • string class = 6

Used in: NonListTypePb, ScalarTypePb, TypePb

(message has no fields)

Used in: FieldDefPb

• oneof kind

  • BoolTypePb bool = 1

  • Int64TypePb int64 = 2

  • DoubleTypePb double = 3

  • StringTypePb string = 4

  • string enum = 5

  • string class = 6

  • VariantTypePb variant = 7

  • ListTypePb list = 8

Definition of a tagged union node type. SWC likes to use enum types to model inheritance. This union type simplifies the AST definitions by allowing us to mimic this model and implicitly add the associated union type as a parent to all the enum members.

Used in: AstDefPb

• optional string name = 1

  Name of the union node. Must be PascalCase. E.g. "BinaryExpression".

• repeated string parents = 2

  Parent nodes to inherit from.

• repeated string types = 3

  Types which are members of this union.

• optional bool should_generate_ir_op = 4

  If true, automatically generate the corresponding op. If false, the op is expected to be manually written.

• repeated FieldKind kinds = 5

  Supported kinds. Each kind leads to a different IR op.

Used in: NonListTypePb, TypePb

• repeated ScalarTypePb types = 1