# Copyright 2019 Google LLC
#
# 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
#
#     https://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.

"""Tests for module_ir."""

from __future__ import print_function

import collections
import pkgutil
import unittest

from compiler.front_end import module_ir
from compiler.front_end import parser
from compiler.front_end import tokenizer
from compiler.util import ir_pb2
from compiler.util import test_util

_TESTDATA_PATH = "testdata.golden"
_MINIMAL_SOURCE = pkgutil.get_data(
        _TESTDATA_PATH, "span_se_log_file_status.emb").decode(encoding="UTF-8")
_MINIMAL_SAMPLE = parser.parse_module(
    tokenizer.tokenize(_MINIMAL_SOURCE, "")[0]).parse_tree
_MINIMAL_SAMPLE_IR = ir_pb2.Module.from_json(
    pkgutil.get_data(_TESTDATA_PATH, "span_se_log_file_status.ir.txt").decode(
        encoding="UTF-8")
)

# _TEST_CASES contains test cases, separated by '===', that ensure that specific
# results show up in the IR for .embs.
#
# Each test case is of the form:
#
#     name
#     ---
#     .emb text
#     ---
#     (incomplete) IR text format
#
# For each test case, the .emb is parsed into a parse tree, which is fed into
# module_ir.build_ir(), which should successfully return an IR.  The generated
# IR is then compared against the incomplete IR in the test case to ensure that
# the generated IR is a strict superset of the test case IR -- that is, it is OK
# if the generated IR contains fields that are not in the test case, but not if
# the test case contains fields that are not in the generated IR, and not if the
# test case contains fields whose values differ from the generated IR.
#
# Additionally, for each test case, a pass is executed to ensure that the source
# code location for each node in the IR is strictly contained within the source
# location for its parent node.
_TEST_CASES = r"""
prelude
---
external UInt:
  [fixed_size: false]
  [byte_order_dependent: true]

external Byte:
  [size: 1]
  [byte_order_dependent: false]
---
{
  "type": [
    {
      "external": {},
      "name": { "name": { "text": "UInt" } },
      "attribute": [
        {
          "name": { "text": "fixed_size" },
          "value": { "expression": { "boolean_constant": { "value": false } } }
        },
        {
          "name": { "text": "byte_order_dependent" },
          "value": { "expression": { "boolean_constant": { "value": true } } }
        }
      ]
    },
    {
      "external": {},
      "name": { "name": { "text": "Byte" } },
      "attribute": [
        {
          "name": { "text": "size" },
          "value": { "expression": { "constant": { "value": "1" } } }
        },
        {
          "name": { "text": "byte_order_dependent" },
          "value": { "expression": { "boolean_constant": { "value": false } } }
        }
      ]
    }
  ]
}

===
numbers
---
bits Foo:
  0000000000          [+0_000_000_003]   UInt  decimal
  0b00000100          [+0b0000_0111]     UInt  binary
  0b00000000_00001000 [+0b0_00001011]    UInt  binary2
  0b_0_00001100       [+0b_00001111]     UInt  binary3
  0x00000010          [+0x0000_0013]     UInt  hex
  0x00000000_00000014 [+0x0_00000017]    UInt  hex2
  0x_0_00000018       [+0x_0000001b]     UInt  hex3
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "decimal" } },
            "location": {
              "start": { "constant": { "value": "0" } },
              "size": { "constant": { "value": "3" } }
            }
          },
          {
            "name": { "name": { "text": "binary" } },
            "location": {
              "start": { "constant": { "value": "4" } },
              "size": { "constant": { "value": "7" }
              }
            }
          },
          {
            "name": { "name": { "text": "binary2" } },
            "location": {
              "start": { "constant": { "value": "8" } },
              "size": { "constant": { "value": "11" } }
            }
          },
          {
            "name": { "name": { "text": "binary3" } },
            "location": {
              "start": { "constant": { "value": "12" } },
              "size": { "constant": { "value": "15" } }
            }
          },
          {
            "name": { "name": { "text": "hex" } },
            "location": {
              "start": { "constant": { "value": "16" } },
              "size": { "constant": { "value": "19" } }
            }
          },
          {
            "name": { "name": { "text": "hex2" } },
            "location": {
              "start": { "constant": { "value": "20" } },
              "size": { "constant": { "value": "23" } }
            }
          },
          {
            "name": { "name": { "text": "hex3" } },
            "location": {
              "start": { "constant": { "value": "24" } },
              "size": { "constant": { "value": "27" } }
            }
          }
        ]
      }
    }
  ]
}

===
enum
---
enum Kind:
  WIDGET = 0
  SPROCKET = 1
  GEEGAW = 2  # Comment.
  MAX32 = 4294967295
  MAX64 = 9223372036854775807
---
{
  "type": [
    {
      "enumeration": {
        "value": [
          {
            "name": { "name": { "text": "WIDGET" } },
            "value": { "constant": { "value": "0" } }
          },
          {
            "name": { "name": { "text": "SPROCKET" } },
            "value": { "constant": { "value": "1" } }
          },
          {
            "name": { "name": { "text": "GEEGAW" } },
            "value": { "constant": { "value": "2" } }
          },
          {
            "name": { "name": { "text": "MAX32" } },
            "value": { "constant": { "value": "4294967295" } }
          },
          {
            "name": { "name": { "text": "MAX64" } },
            "value": { "constant": { "value": "9223372036854775807" } }
          }
        ]
      },
      "name": { "name": { "text": "Kind" } }
    }
  ]
}

===
struct attribute
---
struct Foo:
  [size: 10]
  0 [+0]  UInt  field
---
{
  "type": [
    {
      "structure": {
        "field": [ { "name": { "name": { "text": "field" } } } ]
      },
      "name": { "name": { "text": "Foo" } },
      "attribute": [
        {
          "name": { "text": "size" },
          "value": { "expression": { "constant": { "value": "10" } } },
          "is_default": false
        }
      ]
    }
  ]
}

===
$default attribute
---
[$default byte_order: "LittleEndian"]
---
{
  "attribute": [
    {
      "name": { "text": "byte_order" },
      "value": { "string_constant": { "text": "LittleEndian" } },
      "is_default": true
    }
  ]
}

===
abbreviations
---
struct Foo:
  0 [+1]  UInt  size (s)
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "size" } },
            "abbreviation": { "text": "s" }
          }
        ]
      }
    }
  ]
}

===
expressions
---
struct Foo:
  0+1 [+2*3]             UInt  plus_times
  4-5 [+(6)]             UInt  minus_paren
  nn [+7*(8+9)]          UInt  name_complex
  10+11+12 [+13*14*15]   UInt  associativity
  16+17*18 [+19*20-21]   UInt  precedence
  -(+1) [+0-(-10)]       UInt  unary_plus_minus
  1 + + 2 [+3 - -4 - 5]  UInt  unary_plus_minus_2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "plus_times" } },
            "location": {
              "start": {
                "function": {
                  "function": "ADDITION",
                  "function_name": { "text": "+" },
                  "args": [
                    { "constant": { "value": "0" } },
                    { "constant": { "value": "1" } }
                  ]
                }
              },
              "size": {
                "function": {
                  "function": "MULTIPLICATION",
                  "function_name": { "text": "*" },
                  "args": [
                    { "constant": { "value": "2" } },
                    { "constant": { "value": "3" } }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "minus_paren" } },
            "location": {
              "start": {
                "function": {
                  "function": "SUBTRACTION",
                  "args": [
                    { "constant": { "value": "4" } },
                    { "constant": { "value": "5" } }
                  ]
                }
              },
              "size": { "constant": { "value": "6" } }
            }
          },
          {
            "name": { "name": { "text": "name_complex" } },
            "location": {
              "start": {
                "field_reference": {
                  "path": [ { "source_name": [ { "text": "nn" } ] } ]
                }
              },
              "size": {
                "function": {
                  "function": "MULTIPLICATION",
                  "args": [
                    { "constant": { "value": "7" } },
                    {
                      "function": {
                        "function": "ADDITION",
                        "args": [
                          { "constant": { "value": "8" } },
                          { "constant": { "value": "9" } }
                        ]
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "associativity" } },
            "location": {
              "start": {
                "function": {
                  "function": "ADDITION",
                  "args": [
                    {
                      "function": {
                        "function": "ADDITION",
                        "args": [
                          { "constant": { "value": "10" } },
                          { "constant": { "value": "11" } }
                        ]
                      }
                    },
                    { "constant": { "value": "12" } }
                  ]
                }
              },
              "size": {
                "function": {
                  "function": "MULTIPLICATION",
                  "args": [
                    {
                      "function": {
                        "function": "MULTIPLICATION",
                        "args": [
                          { "constant": { "value": "13" } },
                          { "constant": { "value": "14" } }
                        ]
                      }
                    },
                    { "constant": { "value": "15" } }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "precedence" } },
            "location": {
              "start": {
                "function": {
                  "function": "ADDITION",
                  "args": [
                    { "constant": { "value": "16" } },
                    {
                      "function": {
                        "function": "MULTIPLICATION",
                        "args": [
                          { "constant": { "value": "17" } },
                          { "constant": { "value": "18" } }
                        ]
                      }
                    }
                  ]
                }
              },
              "size": {
                "function": {
                  "function": "SUBTRACTION",
                  "args": [
                    {
                      "function": {
                        "function": "MULTIPLICATION",
                        "args": [
                          { "constant": { "value": "19" } },
                          { "constant": { "value": "20" } }
                        ]
                      }
                    },
                    { "constant": { "value": "21" } }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "unary_plus_minus" } },
            "location": {
              "start": {
                "function": {
                  "function": "SUBTRACTION",
                  "function_name": {
                    "text": "-",
                    "source_location": {
                      "start": { "line": 8, "column": 3 },
                      "end": { "line": 8, "column": 4 }
                    }
                  },
                  "args": [
                    {
                      "constant": {
                        "value": "0",
                        "source_location": {
                          "start": { "line": 8, "column": 3 },
                          "end": { "line": 8, "column": 3 }
                        }
                      },
                      "source_location": {
                        "start": { "line": 8, "column": 3 },
                        "end": { "line": 8, "column": 3 }
                      }
                    },
                    {
                      "function": {
                        "function": "ADDITION",
                        "function_name": {
                          "text": "+",
                          "source_location": {
                            "start": { "line": 8, "column": 5 },
                            "end": { "line": 8, "column": 6 }
                          }
                        },
                        "args": [
                          {
                            "constant": { "value": "0" },
                            "source_location": {
                              "start": { "line": 8, "column": 5 },
                              "end": { "line": 8, "column": 5 }
                            }
                          },
                          {
                            "constant": { "value": "1" },
                            "source_location": {
                              "start": { "line": 8, "column": 6 },
                              "end": { "line": 8, "column": 7 }
                            }
                          }
                        ]
                      },
                      "source_location": {
                        "start": { "line": 8, "column": 4 },
                        "end": { "line": 8, "column": 8 }
                      }
                    }
                  ]
                }
              },
              "size": {
                "function": {
                  "function": "SUBTRACTION",
                  "function_name": {
                    "text": "-",
                    "source_location": {
                      "start": { "line": 8, "column": 12 },
                      "end": { "line": 8, "column": 13 }
                    }
                  },
                  "args": [
                    {
                      "constant": {
                        "value": "0",
                        "source_location": {
                          "start": { "line": 8, "column": 11 },
                          "end": { "line": 8, "column": 12 }
                        }
                      },
                      "source_location": {
                        "start": { "line": 8, "column": 11 },
                        "end": { "line": 8, "column": 12 }
                      }
                    },
                    {
                      "function": {
                        "function": "SUBTRACTION",
                        "function_name": {
                          "text": "-",
                          "source_location": {
                            "start": { "line": 8, "column": 14 },
                            "end": { "line": 8, "column": 15 }
                          }
                        },
                        "args": [
                          {
                            "constant": { "value": "0" },
                            "source_location": {
                              "start": { "line": 8, "column": 14 },
                              "end": { "line": 8, "column": 14 }
                            }
                          },
                          {
                            "constant": { "value": "10" },
                            "source_location": {
                              "start": { "line": 8, "column": 15 },
                              "end": { "line": 8, "column": 17 }
                            }
                          }
                        ]
                      },
                      "source_location": {
                        "start": { "line": 8, "column": 13 },
                        "end": { "line": 8, "column": 18 }
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "unary_plus_minus_2" } },
            "location": {
              "start": {
                "function": {
                  "function": "ADDITION",
                  "args": [
                    { "constant": { "value": "1" } },
                    {
                      "function": {
                        "function": "ADDITION",
                        "args": [
                          { "constant": { "value": "0" } },
                          { "constant": { "value": "2" } }
                        ]
                      }
                    }
                  ]
                }
              },
              "size": {
                "function": {
                  "function": "SUBTRACTION",
                  "args": [
                    {
                      "function": {
                        "function": "SUBTRACTION",
                        "args": [
                          { "constant": { "value": "3" } },
                          {
                            "function": {
                              "function": "SUBTRACTION",
                              "args": [
                                { "constant": { "value": "0" } },
                                { "constant": { "value": "4" } }
                              ]
                            }
                          }
                        ]
                      }
                    },
                    { "constant": { "value": "5" } }
                  ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
auto array size
---
struct TenElementArray:
  0 [+10]  Byte[]  bytes
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "array_type": {
                "base_type": {
                  "atomic_type": {
                    "reference": { "source_name": [ { "text": "Byte" } ] }
                  }
                },
                "automatic": {
                  "source_location": {
                    "start": { "line": 3, "column": 16 },
                    "end": { "line": 3, "column": 18 }
                  }
                }
              }
            },
            "name": { "name": { "text": "bytes" } }
          }
        ]
      }
    }
  ]
}

===
start [+size] ranges
---
struct Foo:
  0 [ + 1 ]  UInt     zero_plus_one
  s [+2]     UInt     s_plus_two
  s [+t]     Byte[t]  s_plus_t
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "zero_plus_one" } },
            "location": {
              "start": {
                "constant": { "value": "0" },
                "source_location": {
                  "start": { "line": 3, "column": 3 },
                  "end": { "line": 3, "column": 4 }
                }
              },
              "size": {
                "constant": { "value": "1" },
                "source_location": {
                  "start": { "line": 3, "column": 9 },
                  "end": { "line": 3, "column": 10 }
                }
              }
            }
          },
          {
            "name": { "name": { "text": "s_plus_two" } },
            "location": {
              "start": {
                "field_reference": {
                  "path": [ { "source_name": [ { "text": "s" } ] } ]
                }
              },
              "size": { "constant": { "value": "2" } }
            }
          },
          {
            "name": { "name": { "text": "s_plus_t" } },
            "location": {
              "start": {
                "field_reference": {
                  "path": [ { "source_name": [ { "text": "s" } ] } ]
                }
              },
              "size": {
                "field_reference": {
                  "path": [ { "source_name": [ { "text": "t" } ] } ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
Using Enum.VALUEs in expressions
---
struct Foo:
  0 [+0+Number.FOUR]  UInt               length_four
  Number.FOUR [+8]    UInt               start_four
  8 [+3*Number.FOUR]  UInt               end_four
  12 [+16]            Byte[Number.FOUR]  array_size_four

enum Number:
  FOUR = 4
  EIGHT = FOUR + Number.FOUR
  SIXTEEN = Number.FOUR * FOUR
  INVALID = Number.NaN.FOUR
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "length_four" } },
            "location": {
              "size": {
                "function": {
                  "function": "ADDITION",
                  "args": [
                    { "constant": { "value": "0" } },
                    {
                      "constant_reference": {
                        "source_name": [
                          { "text": "Number" },
                          { "text": "FOUR" }
                        ]
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "start_four" } },
            "location": {
              "start": {
                "constant_reference": {
                  "source_name": [
                    { "text": "Number" },
                    { "text": "FOUR" }
                  ]
                }
              }
            }
          },
          {
            "name": { "name": { "text": "end_four" } },
            "location": {
              "size": {
                "function": {
                  "function": "MULTIPLICATION",
                  "args": [
                    { "constant": { "value": "3" } },
                    {
                      "constant_reference": {
                        "source_name": [
                          { "text": "Number" },
                          { "text": "FOUR" }
                        ]
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "type": {
              "array_type": {
                "element_count": {
                  "constant_reference": {
                    "source_name": [
                      { "text": "Number" },
                      { "text": "FOUR" }
                    ]
                  }
                }
              }
            },
            "name": { "name": { "text": "array_size_four" } }
          }
        ]
      }
    },
    {
      "enumeration": {
        "value": [
          {
            "name": { "name": { "text": "FOUR" } },
            "value": { "constant": { "value": "4" } }
          },
          {
            "name": { "name": { "text": "EIGHT" } },
            "value": {
              "function": {
                "function": "ADDITION",
                "args": [
                  {
                    "constant_reference": {
                      "source_name": [ { "text": "FOUR" } ]
                    }
                  },
                  {
                    "constant_reference": {
                      "source_name": [
                        { "text": "Number" },
                        { "text": "FOUR" }
                      ]
                    }
                  }
                ]
              }
            }
          },
          {
            "name": { "name": { "text": "SIXTEEN" } },
            "value": {
              "function": {
                "function": "MULTIPLICATION",
                "args": [
                  {
                    "constant_reference": {
                      "source_name": [
                        { "text": "Number" },
                        { "text": "FOUR" }
                      ]
                    }
                  },
                  {
                    "constant_reference": {
                      "source_name": [ { "text": "FOUR" } ]
                    }
                  }
                ]
              }
            }
          },
          {
            "name": { "name": { "text": "INVALID" } },
            "value": {
              "constant_reference": {
                "source_name": [
                  { "text": "Number" },
                  { "text": "NaN" },
                  { "text": "FOUR" }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
Using Type.constants in expressions
---
struct Foo:
  0 [+Bar.four]  UInt  length_four
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "length_four" } },
            "location": {
              "size": {
                "constant_reference": {
                  "source_name": [ { "text": "Bar" }, { "text": "four" } ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
using Type.Subtype
---
struct Foo:
  0 [+0]  Bar.Baz  bar_baz
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [ { "text": "Bar" }, { "text": "Baz" } ]
                }
              }
            },
            "name": { "name": { "text": "bar_baz" } }
          }
        ]
      }
    }
  ]
}

===
module.Type
---
struct Foo:
  0 [+0]  bar.Baz  bar_baz
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [ { "text": "bar" }, { "text": "Baz" } ]
                }
              }
            },
            "name": { "name": { "text": "bar_baz" } }
          }
        ]
      }
    }
  ]
}

===
module.Type.ENUM_VALUE
---
struct Foo:
  bar.Baz.QUX [+0]  UInt  i
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "i" } },
            "location": {
              "start": {
                "constant_reference": {
                  "source_name": [
                    { "text": "bar" },
                    { "text": "Baz" },
                    { "text": "QUX" }
                  ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
field attributes
---
struct Foo:
  0 [+1]  UInt  field  [fixed_size: true]
    [size: 1]
  1 [+2]  UInt  field2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "field"
              }
            },
            "attribute": [
              {
                "name": {
                  "text": "fixed_size"
                },
                "value": {
                  "expression": {
                    "boolean_constant": {
                      "value": true
                    }
                  }
                }
              },
              {
                "name": {
                  "text": "size"
                },
                "value": {
                  "expression": {
                    "constant": {
                      "value": "1"
                    }
                  }
                }
              }
            ]
          },
          {
            "name": {
              "name": {
                "text": "field2"
              }
            }
          }
        ]
      },
      "name": {
        "name": {
          "text": "Foo"
        }
      }
    }
  ]
}

===
enum attribute
---
enum Foo:
  [fixed_size: false]
  NAME = 1
---
{
  "type": [
    {
      "enumeration": {
        "value": [ { "name": { "name": { "text": "NAME" } } } ]
      },
      "name": { "name": { "text": "Foo" } },
      "attribute": [
        {
          "name": { "text": "fixed_size" },
          "value": {
            "expression": { "boolean_constant": { "value": false } }
          }
        }
      ]
    }
  ]
}

===
string attribute
---
[abc: "abc"]
[bs: "abc\\"]
[bsbs: "abc\\\\"]
[nl: "abc\nd"]
[q: "abc\"d"]
[qq: "abc\"\""]
---
{
  "attribute": [
    {
      "name": { "text": "abc" },
      "value": { "string_constant": { "text": "abc" } }
    },
    {
      "name": { "text": "bs" },
      "value": { "string_constant": { "text": "abc\\" } }
    },
    {
      "name": { "text": "bsbs" },
      "value": { "string_constant": { "text": "abc\\\\" } }
    },
    {
      "name": { "text": "nl" },
      "value": { "string_constant": { "text": "abc\nd" } }
    },
    {
      "name": { "text": "q" },
      "value": { "string_constant": { "text": "abc\"d" } }
    },
    {
      "name": { "text": "qq" },
      "value": { "string_constant": { "text": "abc\"\"" } }
    }
  ]
}

===
back-end-specific attribute
---
[(cpp) namespace: "a::b::c"]
---
{
  "attribute": [
    {
      "name": { "text": "namespace" },
      "value": { "string_constant": { "text": "a::b::c" } },
      "back_end": { "text": "cpp" }
    }
  ]
}

===
documentation
---
-- module doc
--
-- module doc 2
struct Foo:
  -- foo doc
  -- foo doc 2
  0 [+1]  UInt  bar  -- bar inline doc
    -- bar continued doc
    -- bar continued doc 2
enum Baz:
  -- baz doc
  -- baz doc 2
  QUX = 1  -- qux inline doc
    -- qux continued doc
    -- qux continued doc 2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "documentation": [
              {
                "text": "bar inline doc"
              },
              {
                "text": "bar continued doc"
              },
              {
                "text": "bar continued doc 2"
              }
            ]
          }
        ]
      },
      "name": {
        "name": {
          "text": "Foo"
        }
      },
      "documentation": [
        {
          "text": "foo doc"
        },
        {
          "text": "foo doc 2"
        }
      ]
    },
    {
      "enumeration": {
        "value": [
          {
            "name": {
              "name": {
                "text": "QUX"
              }
            },
            "documentation": [
              {
                "text": "qux inline doc"
              },
              {
                "text": "qux continued doc"
              },
              {
                "text": "qux continued doc 2"
              }
            ]
          }
        ]
      },
      "name": {
        "name": {
          "text": "Baz"
        }
      },
      "documentation": [
        {
          "text": "baz doc"
        },
        {
          "text": "baz doc 2"
        }
      ]
    }
  ],
  "documentation": [
    {
      "text": "module doc"
    },
    {
      "text": ""
    },
    {
      "text": "module doc 2"
    }
  ]
}

===
inline enum
---
struct Foo:
  0 [+1]  enum  baz_qux_gibble (bqg):
    [q: 5]
    BAR = 1
    FOO = 2
bits Bar:
  0 [+1]  enum  baz_qux_gibble (bqg):
    [q: 5]
    BAR = 1
    FOO = 2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [ { "text": "BazQuxGibble" } ],
                  "is_local_name": true
                }
              }
            },
            "name": { "name": { "text": "baz_qux_gibble" } },
            "abbreviation": { "text": "bqg" },
            "attribute": [
              {
                "name": { "text": "q" },
                "value": { "expression": { "constant": { "value": "5" } } }
              }
            ]
          }
        ]
      },
      "name": { "name": { "text": "Foo" } },
      "subtype": [
        {
          "enumeration": {
            "value": [
              {
                "name": { "name": { "text": "BAR" } },
                "value": { "constant": { "value": "1" } }
              },
              {
                "name": { "name": { "text": "FOO" } },
                "value": { "constant": { "value": "2" } }
              }
            ]
          },
          "name": { "name": { "text": "BazQuxGibble" } }
        }
      ]
    },
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [ { "text": "BazQuxGibble" } ],
                  "is_local_name": true
                }
              }
            },
            "name": { "name": { "text": "baz_qux_gibble" } },
            "abbreviation": { "text": "bqg" },
            "attribute": [
              {
                "name": { "text": "q" },
                "value": { "expression": { "constant": { "value": "5" } } }
              }
            ]
          }
        ]
      },
      "name": { "name": { "text": "Bar" } },
      "subtype": [
        {
          "enumeration": {
            "value": [
              {
                "name": { "name": { "text": "BAR" } },
                "value": { "constant": { "value": "1" } }
              },
              {
                "name": { "name": { "text": "FOO" } },
                "value": { "constant": { "value": "2" } }
              }
            ]
          },
          "name": { "name": { "text": "BazQuxGibble" } }
        }
      ]
    }
  ]
}

===
inline struct
---
struct Foo:
  0 [+1]  struct  baz_qux_gibble (bqg):
    [q: 5]
    0 [+1]  UInt  bar
    1 [+1]  UInt  foo
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [ { "text": "BazQuxGibble" } ],
                  "is_local_name": true
                }
              }
            },
            "name": { "name": { "text": "baz_qux_gibble" } },
            "abbreviation": { "text": "bqg" },
            "attribute": [
              {
                "name": { "text": "q" },
                "value": { "expression": { "constant": { "value": "5" } } }
              }
            ]
          }
        ]
      },
      "name": { "name": { "text": "Foo" } },
      "subtype": [
        {
          "structure": {
            "field": [
              {
                "type": {
                  "atomic_type": {
                    "reference": { "source_name": [ { "text": "UInt" } ] }
                  }
                },
                "name": { "name": { "text": "bar" } }
              },
              {
                "type": {
                  "atomic_type": {
                    "reference": { "source_name": [ { "text": "UInt" } ] }
                  }
                },
                "name": { "name": { "text": "foo" } }
              }
            ]
          },
          "name": { "name": { "text": "BazQuxGibble" } }
        }
      ]
    }
  ]
}

===
inline bits
---
struct Foo:
  0 [+1]  bits  baz_qux_gibble (bqg):
    [q: 5]
    0 [+1]  UInt  bar
    1 [+1]  UInt  foo
bits Bar:
  0 [+8]  bits  baz_qux_gibble (bqg):
    [q: 5]
    0 [+1]  UInt  bar
    1 [+1]  UInt  foo
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [
                    {
                      "text": "BazQuxGibble"
                    }
                  ]
                }
              }
            },
            "name": {
              "name": {
                "text": "baz_qux_gibble"
              }
            },
            "abbreviation": {
              "text": "bqg"
            },
            "attribute": [
              {
                "name": {
                  "text": "q"
                },
                "value": {
                  "expression": {
                    "constant": {
                      "value": "5"
                    }
                  }
                }
              }
            ]
          }
        ]
      },
      "name": {
        "name": {
          "text": "Foo"
        }
      },
      "subtype": [
        {
          "structure": {
            "field": [
              {
                "type": {
                  "atomic_type": {
                    "reference": {
                      "source_name": [
                        {
                          "text": "UInt"
                        }
                      ]
                    }
                  }
                },
                "name": {
                  "name": {
                    "text": "bar"
                  }
                }
              },
              {
                "type": {
                  "atomic_type": {
                    "reference": {
                      "source_name": [
                        {
                          "text": "UInt"
                        }
                      ]
                    }
                  }
                },
                "name": {
                  "name": {
                    "text": "foo"
                  }
                }
              }
            ]
          },
          "name": {
            "name": {
              "text": "BazQuxGibble"
            }
          }
        }
      ]
    },
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": {
                  "source_name": [
                    {
                      "text": "BazQuxGibble"
                    }
                  ]
                }
              }
            },
            "name": {
              "name": {
                "text": "baz_qux_gibble"
              }
            },
            "abbreviation": {
              "text": "bqg"
            },
            "attribute": [
              {
                "name": {
                  "text": "q"
                },
                "value": {
                  "expression": {
                    "constant": {
                      "value": "5"
                    }
                  }
                }
              }
            ]
          }
        ]
      },
      "name": {
        "name": {
          "text": "Bar"
        }
      },
      "subtype": [
        {
          "structure": {
            "field": [
              {
                "type": {
                  "atomic_type": {
                    "reference": {
                      "source_name": [
                        {
                          "text": "UInt"
                        }
                      ]
                    }
                  }
                },
                "name": {
                  "name": {
                    "text": "bar"
                  }
                }
              },
              {
                "type": {
                  "atomic_type": {
                    "reference": {
                      "source_name": [
                        {
                          "text": "UInt"
                        }
                      ]
                    }
                  }
                },
                "name": {
                  "name": {
                    "text": "foo"
                  }
                }
              }
            ]
          },
          "name": {
            "name": {
              "text": "BazQuxGibble"
            }
          }
        }
      ]
    }
  ]
}

===
subfield
---
struct Foo:
  foo.bar [+1]  UInt  x
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "x"
              }
            },
            "location": {
              "start": {
                "field_reference": {
                  "path": [
                    {
                      "source_name": [
                        {
                          "text": "foo"
                        }
                      ]
                    },
                    {
                      "source_name": [
                        {
                          "text": "bar"
                        }
                      ]
                    }
                  ]
                }
              }
            }
          }
        ]
      },
      "name": {
        "name": {
          "text": "Foo"
        }
      }
    }
  ]
}

===
anonymous bits
---
struct Foo:
  0 [+1]  bits:
    31 [+1]    enum  high_bit:
      OFF = 0
      ON  = 1
    0 [+1]     Flag  low_bit
    if false:
      16 [+1]  UInt  mid_high
      15 [+1]  UInt  mid_low
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "is_anonymous": true
            },
            "location": {
              "start": {
                "constant": {
                  "value": "0"
                }
              },
              "size": {
                "constant": {
                  "value": "1"
                }
              }
            }
          }
        ]
      },
      "name": {
        "name": {
          "text": "Foo"
        }
      },
      "subtype": [
        {
          "structure": {
            "field": [
              {
                "name": {
                  "name": {
                    "text": "high_bit"
                  }
                }
              },
              {
                "name": {
                  "name": {
                    "text": "low_bit"
                  }
                }
              },
              {
                "name": {
                  "name": {
                    "text": "mid_high"
                  }
                },
                "existence_condition": {
                  "boolean_constant": {
                    "value": false
                  }
                }
              },
              {
                "name": {
                  "name": {
                    "text": "mid_low"
                  }
                },
                "existence_condition": {
                  "boolean_constant": {
                    "value": false
                  }
                }
              }
            ]
          },
          "name": { "is_anonymous": true }
        },
        {
          "enumeration": {
            "value": [
              {
                "name": { "name": { "text": "OFF" } },
                "value": { "constant": { "value": "0" } }
              },
              {
                "name": { "name": { "text": "ON" } },
                "value": { "constant": { "value": "1" } }
              }
            ]
          },
          "name": { "name": { "text": "HighBit" } }
        }
      ]
    }
  ]
}

===
explicit type size
---
struct Foo:
  0 [+1]  Bar:8  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          { "type": { "size_in_bits": { "constant": { "value": "8" } } } }
        ]
      },
      "name": { "name": { "text": "Foo" } }
    }
  ]
}

===
import
---
import "xyz.emb" as yqf
---
{
  "foreign_import": [
    { "file_name": { "text": "" }, "local_name": { "text": "" } },
    { "file_name": { "text": "xyz.emb" }, "local_name": { "text": "yqf" } }
  ]
}

===
empty file
---
---
{
  "foreign_import": [
    {
      "file_name": {
        "text": "",
        "source_location": {
          "start": { "line": 1, "column": 1 },
          "end": { "line": 1, "column": 1 }
        }
      },
      "local_name": {
        "text": "",
        "source_location": {
          "start": { "line": 1, "column": 1 },
          "end": { "line": 1, "column": 1 }
        }
      },
      "source_location": {
        "start": { "line": 1, "column": 1 },
        "end": { "line": 1, "column": 1 }
      }
    }
  ],
  "source_location": {
    "start": { "line": 1, "column": 1 },
    "end": { "line": 1, "column": 1 }
  }
}

===
existence_condition on unconditional field
---
struct Foo:
  0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "bar" } },
            "existence_condition": { "boolean_constant": { "value": true } }
          }
        ]
      }
    }
  ]
}

===
conditional struct fields
---
struct Foo:
  if true == false:
    0 [+1]  UInt  bar
    1 [+1]  bits:
      0 [+1]  UInt  xx
      1 [+1]  UInt  yy
    2 [+1]  enum  baz:
      XX = 1
      YY = 2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "bar" } },
            "existence_condition": {
              "function": {
                "function": "EQUALITY",
                "args": [
                  { "boolean_constant": { "value": true } },
                  { "boolean_constant": { "value": false } }
                ]
              }
            }
          },
          {
            "existence_condition": {
              "function": {
                "function": "EQUALITY",
                "args": [
                  { "boolean_constant": { "value": true } },
                  { "boolean_constant": { "value": false } }
                ]
              }
            }
          },
          {
            "name": { "name": { "text": "baz" } },
            "existence_condition": {
              "function": {
                "function": "EQUALITY",
                "args": [
                  { "boolean_constant": { "value": true } },
                  { "boolean_constant": { "value": false } }
                ]
              }
            }
          }
        ]
      },
      "subtype": [
        {
          "structure": {
            "field": [
              {
                "name": { "name": { "text": "xx" } },
                "existence_condition": { "boolean_constant": { "value": true } }
              }
            ]
          }
        }
      ]
    }
  ]
}

===
negative condition
---
struct Foo:
  if true != false:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "bar" } },
            "existence_condition": {
              "function": {
                "function": "INEQUALITY",
                "args": [
                  { "boolean_constant": { "value": true } },
                  { "boolean_constant": { "value": false } }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional bits fields
---
bits Foo:
  if true == false:
    0 [+1]  UInt  bar
    1 [+1]  enum  baz:
      XX = 1
      YY = 2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "bar" } },
            "existence_condition": {
              "function": {
                "function": "EQUALITY",
                "args": [
                  { "boolean_constant": { "value": true } },
                  { "boolean_constant": { "value": false } }
                ]
              }
            }
          },
          {
            "name": { "name": { "text": "baz" } },
            "existence_condition": {
              "function": {
                "function": "EQUALITY",
                "args": [
                  { "boolean_constant": { "value": true } },
                  { "boolean_constant": { "value": false } }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional with logical and
---
struct Foo:
  if true && false:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "boolean_constant": {
                      "value": true
                    }
                  },
                  {
                    "boolean_constant": {
                      "value": false
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional with logical or
---
struct Foo:
  if true || false:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "OR",
                "args": [
                  {
                    "boolean_constant": {
                      "value": true
                    }
                  },
                  {
                    "boolean_constant": {
                      "value": false
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional with multiple logical ands
---
struct Foo:
  if true && false && true:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "AND",
                      "args": [
                        {
                          "boolean_constant": {
                            "value": true
                          }
                        },
                        {
                          "boolean_constant": {
                            "value": false
                          }
                        }
                      ]
                    }
                  },
                  {
                    "boolean_constant": {
                      "value": true
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional with multiple logical ors
---
struct Foo:
  if true || false || true:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "OR",
                "args": [
                  {
                    "function": {
                      "function": "OR",
                      "args": [
                        {
                          "boolean_constant": {
                            "value": true
                          }
                        },
                        {
                          "boolean_constant": {
                            "value": false
                          }
                        }
                      ]
                    }
                  },
                  {
                    "boolean_constant": {
                      "value": true
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional with comparisons and logical or
---
struct Foo:
  if 5 == 6 || 6 == 6:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "OR",
                "args": [
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "5"
                          }
                        },
                        {
                          "constant": {
                            "value": "6"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "6"
                          }
                        },
                        {
                          "constant": {
                            "value": "6"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
conditional with or-of-ands
---
struct Foo:
  if true || (false && true):
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "OR",
                "args": [
                  {
                    "boolean_constant": {
                      "value": true
                    }
                  },
                  {
                    "function": {
                      "function": "AND",
                      "args": [
                        {
                          "boolean_constant": {
                            "value": false
                          }
                        },
                        {
                          "boolean_constant": {
                            "value": true
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
less-than comparison
---
struct Foo:
  if 1 < 2:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "LESS",
                "args": [
                  {
                    "constant": {
                      "value": "1"
                    }
                  },
                  {
                    "constant": {
                      "value": "2"
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
less-than-or-equal comparison
---
struct Foo:
  if 1 <= 2:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "LESS_OR_EQUAL",
                "args": [
                  {
                    "constant": {
                      "value": "1"
                    }
                  },
                  {
                    "constant": {
                      "value": "2"
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
greater-than comparison
---
struct Foo:
  if 1 > 2:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "GREATER",
                "args": [
                  {
                    "constant": {
                      "value": "1"
                    }
                  },
                  {
                    "constant": {
                      "value": "2"
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
greater-than-or-equal comparison
---
struct Foo:
  if 1 >= 2:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "GREATER_OR_EQUAL",
                "args": [
                  {
                    "constant": {
                      "value": "1"
                    }
                  },
                  {
                    "constant": {
                      "value": "2"
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained less-than comparison
---
struct Foo:
  if 1 < 2 < 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "LESS",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "LESS",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained greater-than comparison
---
struct Foo:
  if 1 > 2 > 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "GREATER",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "GREATER",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
longer chained less-than comparison
---
struct Foo:
  if 1 < 2 < 3 <= 4:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "AND",
                      "args": [
                        {
                          "function": {
                            "function": "LESS",
                            "args": [
                              {
                                "constant": {
                                  "value": "1"
                                }
                              },
                              {
                                "constant": {
                                  "value": "2"
                                }
                              }
                            ]
                          }
                        },
                        {
                          "function": {
                            "function": "LESS",
                            "args": [
                              {
                                "constant": {
                                  "value": "2"
                                }
                              },
                              {
                                "constant": {
                                  "value": "3"
                                }
                              }
                            ]
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "LESS_OR_EQUAL",
                      "args": [
                        {
                          "constant": {
                            "value": "3"
                          }
                        },
                        {
                          "constant": {
                            "value": "4"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
longer chained greater-than comparison
---
struct Foo:
  if 1 > 2 > 3 >= 4:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "AND",
                      "args": [
                        {
                          "function": {
                            "function": "GREATER",
                            "args": [
                              {
                                "constant": {
                                  "value": "1"
                                }
                              },
                              {
                                "constant": {
                                  "value": "2"
                                }
                              }
                            ]
                          }
                        },
                        {
                          "function": {
                            "function": "GREATER",
                            "args": [
                              {
                                "constant": {
                                  "value": "2"
                                }
                              },
                              {
                                "constant": {
                                  "value": "3"
                                }
                              }
                            ]
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "GREATER_OR_EQUAL",
                      "args": [
                        {
                          "constant": {
                            "value": "3"
                          }
                        },
                        {
                          "constant": {
                            "value": "4"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained less-than and equal comparison
---
struct Foo:
  if 1 < 2 == 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "LESS",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained greater-than and equal comparison
---
struct Foo:
  if 1 > 2 == 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "GREATER",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained equal and less-than comparison
---
struct Foo:
  if 1 == 2 < 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "LESS",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained equal and greater-than comparison
---
struct Foo:
  if 1 == 2 > 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "GREATER",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
chained equality comparison
---
struct Foo:
  if 1 == 2 == 3:
    0 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "existence_condition": {
              "function": {
                "function": "AND",
                "args": [
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "1"
                          }
                        },
                        {
                          "constant": {
                            "value": "2"
                          }
                        }
                      ]
                    }
                  },
                  {
                    "function": {
                      "function": "EQUALITY",
                      "args": [
                        {
                          "constant": {
                            "value": "2"
                          }
                        },
                        {
                          "constant": {
                            "value": "3"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
choice operator
---
struct Foo:
  true ? 0 : 1 [+1]  UInt  bar
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "bar"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "CHOICE",
                  "args": [
                    {
                      "boolean_constant": {
                        "value": true
                      }
                    },
                    {
                      "constant": {
                        "value": "0"
                      }
                    },
                    {
                      "constant": {
                        "value": "1"
                      }
                    }
                  ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
max function
---
struct Foo:
  $max()               [+1]  UInt  no_arg
  $max(0)              [+1]  UInt  one_arg
  $max(2 * 3)          [+1]  UInt  mul_arg
  $max(2, 3)           [+1]  UInt  two_arg
  $max(2, 3, 4, 5, 6)  [+1]  UInt  five_arg
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "no_arg"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "MAXIMUM"
                }
              }
            }
          },
          {
            "name": {
              "name": {
                "text": "one_arg"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "MAXIMUM",
                  "args": [
                    {
                      "constant": {
                        "value": "0"
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "name": {
              "name": {
                "text": "mul_arg"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "MAXIMUM",
                  "args": [
                    {
                      "function": {
                        "function": "MULTIPLICATION",
                        "args": [
                          {
                            "constant": {
                              "value": "2"
                            }
                          },
                          {
                            "constant": {
                              "value": "3"
                            }
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "name": {
              "name": {
                "text": "two_arg"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "MAXIMUM",
                  "args": [
                    {
                      "constant": {
                        "value": "2"
                      }
                    },
                    {
                      "constant": {
                        "value": "3"
                      }
                    }
                  ]
                }
              }
            }
          },
          {
            "name": {
              "name": {
                "text": "five_arg"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "MAXIMUM",
                  "args": [
                    {
                      "constant": {
                        "value": "2"
                      }
                    },
                    {
                      "constant": {
                        "value": "3"
                      }
                    },
                    {
                      "constant": {
                        "value": "4"
                      }
                    },
                    {
                      "constant": {
                        "value": "5"
                      }
                    },
                    {
                      "constant": {
                        "value": "6"
                      }
                    }
                  ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
has function
---
struct Foo:
  if $present(x):
    0 [+1]  UInt  field
  if $present(x.y.z):
    0 [+1]  UInt  field2
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "field"
              }
            },
            "existence_condition": {
              "function": {
                "function": "PRESENCE",
                "args": [
                  {
                    "field_reference": {
                      "path": [
                        {
                          "source_name": [
                            {
                              "text": "x"
                            }
                          ]
                        }
                      ]
                    }
                  }
                ]
              }
            }
          },
          {
            "name": {
              "name": {
                "text": "field2"
              }
            },
            "existence_condition": {
              "function": {
                "function": "PRESENCE",
                "args": [
                  {
                    "field_reference": {
                      "path": [
                        {
                          "source_name": [
                            {
                              "text": "x"
                            }
                          ]
                        },
                        {
                          "source_name": [
                            {
                              "text": "y"
                            }
                          ]
                        },
                        {
                          "source_name": [
                            {
                              "text": "z"
                            }
                          ]
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
upper_bound function
---
struct Foo:
  $upper_bound(0)    [+1]  UInt  one
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "one"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "UPPER_BOUND",
                  "args": [
                    {
                      "constant": {
                        "value": "0"
                      }
                    }
                  ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
lower_bound function
---
struct Foo:
  $lower_bound(0)    [+1]  UInt  one
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": {
              "name": {
                "text": "one"
              }
            },
            "location": {
              "start": {
                "function": {
                  "function": "LOWER_BOUND",
                  "args": [
                    {
                      "constant": {
                        "value": "0"
                      }
                    }
                  ]
                }
              }
            }
          }
        ]
      }
    }
  ]
}

===
struct addressable_unit
---
struct Foo:
  0 [+1]  UInt  size
---
{ "type": [ { "structure": {}, "addressable_unit": "BYTE" } ] }

===
bits addressable_unit
---
bits Foo:
  0 [+1]  UInt  size
---
{ "type": [ { "structure": {}, "addressable_unit": "BIT" } ] }

===
enum addressable_unit
---
enum Foo:
  BAR = 0
---
{ "type": [ { "enumeration": {}, "addressable_unit": "BIT" } ] }

===
type size source_location
---
struct Foo:
  0 [+4]  UInt:32  field
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": { "source_name": [ { "text": "UInt" } ] }
              },
              "size_in_bits": {
                "source_location": {
                  "start": { "line": 3, "column": 15 },
                  "end": { "line": 3, "column": 18 }
                }
              },
              "source_location": {
                "start": { "line": 3, "column": 11 },
                "end": { "line": 3, "column": 18 }
              }
            },
            "name": { "name": { "text": "field" } }
          }
        ]
      }
    }
  ]
}

===
builtin references
---
external Foo:
  [requires: $is_statically_sized && $static_size_in_bits == 64]
---
{
  "type": [
    {
      "external": {},
      "attribute": [
        {
          "name": { "text": "requires" },
          "value": {
            "expression": {
              "function": {
                "args": [
                  {
                    "builtin_reference": {
                      "canonical_name": {
                        "module_file": "",
                        "object_path": [ "$is_statically_sized" ]
                      },
                      "source_name": [ { "text": "$is_statically_sized" } ]
                    }
                  },
                  {
                    "function": {
                      "args": [
                        {
                          "builtin_reference": {
                            "canonical_name": {
                              "module_file": "",
                              "object_path": [ "$static_size_in_bits" ]
                            },
                            "source_name": [
                              { "text": "$static_size_in_bits" }
                            ]
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  ]
}

===
$next
---
struct Foo:
  $next [+0]  UInt  x
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "location": {
              "start": {
                "builtin_reference": { "source_name": [ { "text": "$next" } ] }
              }
            },
            "name": { "name": { "text": "x" } }
          }
        ]
      }
    }
  ]
}

===
virtual fields
---
struct Foo:
  let x = 10
bits Bar:
  let y = 100
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "x" } },
            "read_transform": { "constant": { "value": "10" } }
          }
        ]
      }
    },
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "y" } },
            "read_transform": { "constant": { "value": "100" } }
          }
        ]
      }
    }
  ]
}

===
builtin fields
---
struct Foo:
  let x = $size_in_bytes
  let y = $max_size_in_bytes
  let z = $min_size_in_bytes
bits Bar:
  let x = $size_in_bits
  let y = $max_size_in_bits
  let z = $min_size_in_bits
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "x" } },
            "read_transform": {
              "field_reference": {
                "path": [ { "source_name": [ { "text": "$size_in_bytes" } ] } ]
              }
            }
          },
          {
            "name": { "name": { "text": "y" } },
            "read_transform": {
              "field_reference": {
                "path": [
                  { "source_name": [ { "text": "$max_size_in_bytes" } ] }
                ]
              }
            }
          },
          {
            "name": { "name": { "text": "z" } },
            "read_transform": {
              "field_reference": {
                "path": [
                  { "source_name": [ { "text": "$min_size_in_bytes" } ] }
                ]
              }
            }
          }
        ]
      }
    },
    {
      "structure": {
        "field": [
          {
            "name": { "name": { "text": "x" } },
            "read_transform": {
              "field_reference": {
                "path": [ { "source_name": [ { "text": "$size_in_bits" } ] } ]
              }
            }
          },
          {
            "name": { "name": { "text": "y" } },
            "read_transform": {
              "field_reference": {
                "path": [
                  { "source_name": [ { "text": "$max_size_in_bits" } ] }
                ]
              }
            }
          },
          {
            "name": { "name": { "text": "z" } },
            "read_transform": {
              "field_reference": {
                "path": [
                  { "source_name": [ { "text": "$min_size_in_bits" } ] }
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

===
parameterized type definitions
---
struct Foo(a: Flag, b: UInt:32):
  let x = 10
bits Bar(c: UInt:16):
  let y = 100
struct Baz():
  let x = 10
---
{
  "type": [
    {
      "runtime_parameter": [
        {
          "name": { "name": { "text": "a" } },
          "physical_type_alias": {
            "atomic_type": {
              "reference": { "source_name": [ { "text": "Flag" } ] }
            }
          }
        },
        {
          "name": { "name": { "text": "b" } },
          "physical_type_alias": {
            "atomic_type": {
              "reference": { "source_name": [ { "text": "UInt" } ] }
            },
            "size_in_bits": { "constant": { "value": "32" } }
          }
        }
      ]
    },
    {
      "runtime_parameter": [
        {
          "name": { "name": { "text": "c" } },
          "physical_type_alias": {
            "atomic_type": {
              "reference": { "source_name": [ { "text": "UInt" } ] }
            },
            "size_in_bits": { "constant": { "value": "16" } }
          }
        }
      ]
    },
    {}
  ]
}

===
parameterized type usages
---
struct Foo:
  0 [+1]  Two(1, 2)  two
  1 [+1]  One(3)     one
  2 [+1]  Zero()     zero
---
{
  "type": [
    {
      "structure": {
        "field": [
          {
            "type": {
              "atomic_type": {
                "reference": { "source_name": [ { "text": "Two" } ] },
                "runtime_parameter": [
                  { "constant": { "value": "1" } },
                  { "constant": { "value": "2" } }
                ]
              }
            },
            "name": { "name": { "text": "two" } }
          },
          {
            "type": {
              "atomic_type": {
                "reference": { "source_name": [ { "text": "One" } ] },
                "runtime_parameter": [ { "constant": { "value": "3" } } ]
              }
            },
            "name": { "name": { "text": "one" } }
          },
          {
            "type": {
              "atomic_type": {
                "reference": { "source_name": [ { "text": "Zero" } ] }
              }
            },
            "name": { "name": { "text": "zero" } }
          }
        ]
      }
    }
  ]
}

===
enum value attribute
---
enum Foo:
  BAR     = 1 [test: 0]
  BAZ     = 2
    [test: 1]
    [different: "test"]
  FOO_BAR = 4
    -- foo bar doc
    [test: 2]
  FOO_BAZ = 8 [test: 3] -- foo baz doc
  BAR_FOO = 16 [test: 4]
    -- bar foo doc
  BAZ_FOO = 32 -- baz foo doc
    [test: 5]
---
{
  "type": [
    {
      "enumeration": {
        "value": [
          {
            "name": { "name": { "text": "BAR" } },
            "attribute": [
              {
                "name": { "text": "test" },
                "value": { "expression": { "constant": { "value": "0" } } }
              }
            ]
          },
          {
            "name": { "name": { "text": "BAZ" } },
            "attribute": [
              {
                "name": { "text": "test" },
                "value": { "expression": { "constant": { "value": "1" } } }
              },
              {
                "name": { "text": "different" },
                "value": { "string_constant": { "text": "test" } }
              }
            ]
          },
          {
            "name": { "name": { "text": "FOO_BAR" } },
            "documentation": [ { "text": "foo bar doc" } ],
            "attribute": [
              {
                "name": { "text": "test" },
                "value": { "expression": { "constant": { "value": "2" } } }
              }
            ]
          },
          {
            "name": { "name": { "text": "FOO_BAZ" } },
            "documentation": [ { "text": "foo baz doc" } ],
            "attribute": [
              {
                "name": { "text": "test" },
                "value": { "expression": { "constant": { "value": "3" } } }
              }
            ]
          },
          {
            "name": { "name": { "text": "BAR_FOO" } },
            "documentation": [ { "text": "bar foo doc" } ],
            "attribute": [
              {
                "name": { "text": "test" },
                "value": { "expression": { "constant": { "value": "4" } } }
              }
            ]
          },
          {
            "name": { "name": { "text": "BAZ_FOO" } },
            "documentation": [ { "text": "baz foo doc" } ],
            "attribute": [
              {
                "name": { "text": "test" },
                "value": { "expression": { "constant": { "value": "5" } } }
              }
            ]
          }
        ]
      },
      "name": { "name": { "text": "Foo" } }
    }
  ]
}

"""


# For each test in _NEGATIVE_TEST_CASES, parsing should fail, and the failure
# should indicate the specified token.
_NEGATIVE_TEST_CASES = """
anonymous bits does not allow documentation
---
-- doc
---
struct Foo:
  0 [+1]  bits:
    -- doc
    0 [+2]  UInt  bar
===
anonymous bits does not allow subtypes
---
enum
---
struct Foo:
  0 [+1]  bits:
    enum Bar:
      X = 1
    0 [+2]  Bar  bar
"""


def _get_test_cases():
  test_case = collections.namedtuple("test_case", ["name", "parse_tree", "ir"])
  result = []
  for case in _TEST_CASES.split("==="):
    name, emb, ir_text = case.split("---")
    name = name.strip()
    try:
      ir = ir_pb2.Module.from_json(ir_text)
    except Exception:
      print(name)
      raise
    parse_result = parser.parse_module(tokenizer.tokenize(emb, "")[0])
    assert not parse_result.error, "{}:\n{}".format(name, parse_result.error)
    result.append(test_case(name, parse_result.parse_tree, ir))
  return result


def _get_negative_test_cases():
  test_case = collections.namedtuple("test_case",
                                     ["name", "text", "error_token"])
  result = []
  for case in _NEGATIVE_TEST_CASES.split("==="):
    name, error_token, text = case.split("---")
    name = name.strip()
    error_token = error_token.strip()
    result.append(test_case(name, text, error_token))
  return result


def _check_source_location(source_location, path, min_start, max_end):
  """Performs sanity checks on a source_location field.

  Arguments:
    source_location: The source_location to check.
    path: The path, to use in error messages.
    min_start: A minimum value for source_location.start, or None.
    max_end: A maximum value for source_location.end, or None.

  Returns:
    A list of error messages, or an empty list if no errors.
  """
  if source_location.is_disjoint_from_parent:
    # If source_location.is_disjoint_from_parent, then this source_location is
    # allowed to be outside of the parent's source_location.
    return []

  result = []
  start = None
  end = None
  if not source_location.HasField("start"):
    result.append("{}.start missing".format(path))
  else:
    start = source_location.start
  if not source_location.HasField("end"):
    result.append("{}.end missing".format(path))
  else:
    end = source_location.end

  if start and end:
    if start.HasField("line") and end.HasField("line"):
      if start.line > end.line:
        result.append("{}.start.line > {}.end.line ({} vs {})".format(
            path, path, start.line, end.line))
      elif start.line == end.line:
        if (start.HasField("column") and end.HasField("column") and
            start.column > end.column):
          result.append("{}.start.column > {}.end.column ({} vs {})".format(
              path, path, start.column, end.column))

  for name, field in (("start", start), ("end", end)):
    if not field:
      continue
    if field.HasField("line"):
      if field.line <= 0:
        result.append("{}.{}.line <= 0 ({})".format(path, name, field.line))
    else:
      result.append("{}.{}.line missing".format(path, name))
    if field.HasField("column"):
      if field.column <= 0:
        result.append("{}.{}.column <= 0 ({})".format(path, name, field.column))
    else:
      result.append("{}.{}.column missing".format(path, name))

  if min_start and start:
    if min_start.line > start.line or (
        min_start.line == start.line and min_start.column > start.column):
      result.append("{}.start before parent start".format(path))

  if max_end and end:
    if max_end.line < end.line or (
        max_end.line == end.line and max_end.column < end.column):
      result.append("{}.end after parent end".format(path))

  return result


def _check_all_source_locations(proto, path="", min_start=None, max_end=None):
  """Performs sanity checks on all source_locations in proto.

  Arguments:
    proto: The proto to recursively check.
    path: The path, to use in error messages.
    min_start: A minimum value for source_location.start, or None.
    max_end: A maximum value for source_location.end, or None.

  Returns:
    A list of error messages, or an empty list if no errors.
  """
  if path:
    path += "."

  errors = []

  child_start = None
  child_end = None
  # Only check the source_location value if this proto message actually has a
  # source_location field.
  if "source_location" in proto.raw_fields:
    errors.extend(_check_source_location(proto.source_location,
                                         path + "source_location",
                                         min_start, max_end))
    child_start = proto.source_location.start
    child_end = proto.source_location.end

  for name, spec in proto.field_specs.items():
    if name == "source_location":
      continue
    if not proto.HasField(name):
      continue
    field_path = "{}{}".format(path, name)
    if isinstance(spec, ir_pb2.Repeated):
      if issubclass(spec.type, ir_pb2.Message):
        index = 0
        for i in getattr(proto, name):
          item_path = "{}[{}]".format(field_path, index)
          index += 1
          errors.extend(
              _check_all_source_locations(i, item_path, child_start, child_end))
    else:
      if issubclass(spec.type, ir_pb2.Message):
        errors.extend(_check_all_source_locations(getattr(proto, name),
                                                  field_path, child_start,
                                                  child_end))

  return errors


class ModuleIrTest(unittest.TestCase):
  """Tests the module_ir.build_ir() function."""

  def test_build_ir(self):
    ir = module_ir.build_ir(_MINIMAL_SAMPLE)
    ir.source_text = _MINIMAL_SOURCE
    self.assertEqual(ir, _MINIMAL_SAMPLE_IR)

  def test_production_coverage(self):
    """Checks that all grammar productions are used somewhere in tests."""
    used_productions = set()
    module_ir.build_ir(_MINIMAL_SAMPLE, used_productions)
    for test in _get_test_cases():
      module_ir.build_ir(test.parse_tree, used_productions)
    self.assertEqual(set(module_ir.PRODUCTIONS) - used_productions, set([]))

  def test_double_negative_non_compilation(self):
    """Checks that unparenthesized double unary minus/plus is a parse error."""
    for example in ("[x: - -3]", "[x: + -3]", "[x: - +3]", "[x: + +3]"):
      parse_result = parser.parse_module(tokenizer.tokenize(example, "")[0])
      self.assertTrue(parse_result.error)
      self.assertEqual(7, parse_result.error.token.source_location.start.column)
    for example in ("[x:-(-3)]", "[x:+(-3)]", "[x:-(+3)]", "[x:+(+3)]"):
      parse_result = parser.parse_module(tokenizer.tokenize(example, "")[0])
      self.assertFalse(parse_result.error)


def _make_superset_tests():

  def _make_superset_test(test):

    def test_case(self):
      ir = module_ir.build_ir(test.parse_tree)
      is_superset, error_message = test_util.proto_is_superset(ir, test.ir)
      self.assertTrue(
          is_superset,
          error_message + "\n" + ir.to_json(indent=2) + "\n" +
          test.ir.to_json(indent=2))

    return test_case

  for test in _get_test_cases():
    test_name = "test " + test.name + " proto superset"
    assert not hasattr(ModuleIrTest, test_name)
    setattr(ModuleIrTest, test_name, _make_superset_test(test))


def _make_source_location_tests():

  def _make_source_location_test(test):

    def test_case(self):
      error_list = _check_all_source_locations(
          module_ir.build_ir(test.parse_tree))
      self.assertFalse(error_list, "\n".join([test.name] + error_list))

    return test_case

  for test in _get_test_cases():
    test_name = "test " + test.name + " source location"
    assert not hasattr(ModuleIrTest, test_name)
    setattr(ModuleIrTest, test_name, _make_source_location_test(test))


def _make_negative_tests():

  def _make_negative_test(test):

    def test_case(self):
      parse_result = parser.parse_module(tokenizer.tokenize(test.text, "")[0])
      self.assertEqual(test.error_token, parse_result.error.token.text.strip())

    return test_case

  for test in _get_test_cases():
    test_name = "test " + test.name + " compilation failure"
    assert not hasattr(ModuleIrTest, test_name)
    setattr(ModuleIrTest, test_name, _make_negative_test(test))


_make_superset_tests()
_make_source_location_tests()


if __name__ == "__main__":
  unittest.main()