Bind fixed-size arrays to a different built-in type without push/pop

crates/solidity/inputs/language/bindings/rules.msgb

@@ -842,14 +842,22 @@ inherit .lexical_scope
   node @array.output
 }
 
+@array [ArrayTypeName [TypeName] index: [Expression]] {
+  let @array.type = "%arrayFixed"
+}
+
+@array [ArrayTypeName [OpenBracket] . [CloseBracket]] {
+  let @array.type = "%array"
+}
+
 @array [ArrayTypeName @type_name [TypeName]] {
   ; First define the normal, reference route:
 
   ; We first push the array type `%array`, which should connect to two distinct paths:
   ; 1. the typed path, which will use a jump scope entry to resolve the element type
   ; 2. the hard-coded path to connect to any `using` directive
   node array
-  attr (array) push_symbol = "%array"
+  attr (array) push_symbol = @array.type
   edge @array.output -> array
 
   ; For the first path, we need to define a scope jump entry for resolving the element type of the array
@@ -875,7 +883,7 @@ inherit .lexical_scope
   ; Now we define the "definition" route (aka. the pop route), to use in `using` directives only
   ; This is essentially the reverse of the second path above
   node pop_array
-  attr (pop_array) pop_symbol = "%array"
+  attr (pop_array) pop_symbol = @array.type
 
   let @array.pop_begin = @type_name.pop_begin
   edge @type_name.pop_end -> pop_array

crates/solidity/inputs/language/src/definition.rs

@@ -6849,6 +6849,15 @@ codegen_language_macros::compile!(Language(
                 BuiltInFunction(name = "pop", parameters = [])
             ]
         ),
+        BuiltInType(
+            name = "$arrayFixed",
+            fields = [BuiltInField(definition = "uint length")],
+            functions = [BuiltInFunction(
+                name = "$index",
+                parameters = ["uint"],
+                return_type = "$element"
+            )]
+        ),
         BuiltInType(
             name = "$blockType",
             fields = [

crates/solidity/testing/snapshots/bindings_assertions/arrays/fixed.sol

@@ -0,0 +1,9 @@
+contract Test {
+    function test() public {
+        uint[5] memory values;
+        values.pop();
+        //     ^ref:!  -- fixed size arrays should not bind pop/push
+        values.push(1);
+        //     ^ref:!  -- fixed size arrays should not bind pop/push
+    }
+}

crates/solidity/testing/snapshots/bindings_output/built_ins/arrays/generated/0.4.11-success.txt

@@ -12,9 +12,9 @@ References and definitions:
   3 │     function testArray() public {
     │              ────┬────  
     │                  ╰────── def: 3
-  4 │         uint[] memory b = new uint[](5);
-    │                       ┬  
-    │                       ╰── def: 4
+  4 │         uint[] storage b = new uint[](5);
+    │                        ┬  
+    │                        ╰── def: 4
   5 │         assert(b.length == 5);
     │         ───┬── ┬ ───┬──  
     │            ╰───────────── ref: built-in

crates/solidity/testing/snapshots/bindings_output/built_ins/arrays/generated/0.6.0-success.txt

@@ -12,9 +12,9 @@ References and definitions:
   3 │     function testArray() public {
     │              ────┬────  
     │                  ╰────── def: 3
-  4 │         uint[] memory b = new uint[](5);
-    │                       ┬  
-    │                       ╰── def: 4
+  4 │         uint[] storage b = new uint[](5);
+    │                        ┬  
+    │                        ╰── def: 4
   5 │         assert(b.length == 5);
     │         ───┬── ┬ ───┬──  
     │            ╰───────────── ref: built-in

crates/solidity/testing/snapshots/bindings_output/built_ins/arrays/input.sol

@@ -1,7 +1,7 @@
 contract Test {
     uint[] a;
     function testArray() public {
-        uint[] memory b = new uint[](5);
+        uint[] storage b = new uint[](5);
         assert(b.length == 5);
 
         a.push();