feat: add support for u16/i16

compiler/noirc_frontend/src/ast/mod.rs

@@ -32,6 +32,7 @@
 pub enum IntegerBitSize {
     One,
     Eight,
+    Sixteen,
     ThirtyTwo,
     SixtyFour,
 }
@@ -48,6 +49,7 @@
         match size {
             One => 1,
             Eight => 8,
+            Sixteen => 16,
             ThirtyTwo => 32,
             SixtyFour => 64,
         }
@@ -64,6 +66,7 @@
         match value {
             1 => Ok(One),
             8 => Ok(Eight),
+            16 => Ok(Sixteen),
             32 => Ok(ThirtyTwo),
             64 => Ok(SixtyFour),
             _ => Err(InvalidIntegerBitSizeError(value)),
@@ -112,7 +115,7 @@
         /*env:*/ Box<UnresolvedType>,
     ),
 
     // The type of quoted code for metaprogramming
     Code,
 
     Unspecified, // This is for when the user declares a variable without specifying it's type

compiler/noirc_frontend/src/hir/comptime/tests.rs

@@ -103,6 +103,19 @@ fn for_loop() {
     assert_eq!(result, Value::U8(15));
 }
 
+#[test]
+fn for_loop_u16() {
+    let program = "fn main() -> pub u16 {
+        let mut x = 0;
+        for i in 0 .. 6 {
+            x += i;
+        }
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::U16(15));
+}
+
 #[test]
 fn for_loop_with_break() {
     let program = "unconstrained fn main() -> pub u32 {

compiler/noirc_frontend/src/hir/comptime/value.rs

@@ -22,9 +22,11 @@ pub enum Value {
     Bool(bool),
     Field(FieldElement),
     I8(i8),
+    I16(i16),
     I32(i32),
     I64(i64),
     U8(u8),
+    U16(u16),
     U32(u32),
     U64(u64),
     String(Rc<String>),
@@ -45,9 +47,11 @@ impl Value {
             Value::Bool(_) => Type::Bool,
             Value::Field(_) => Type::FieldElement,
             Value::I8(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Eight),
+            Value::I16(_) => Type::Integer(Signedness::Signed, IntegerBitSize::Sixteen),
             Value::I32(_) => Type::Integer(Signedness::Signed, IntegerBitSize::ThirtyTwo),
             Value::I64(_) => Type::Integer(Signedness::Signed, IntegerBitSize::SixtyFour),
             Value::U8(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
+            Value::U16(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::Sixteen),
             Value::U32(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::ThirtyTwo),
             Value::U64(_) => Type::Integer(Signedness::Unsigned, IntegerBitSize::SixtyFour),
             Value::String(value) => {
@@ -87,6 +91,12 @@ impl Value {
                 let value = (value as u128).into();
                 HirExpression::Literal(HirLiteral::Integer(value, negative))
             }
+            Value::I16(value) => {
+                let negative = value < 0;
+                let value = value.abs();
+                let value = (value as u128).into();
+                HirExpression::Literal(HirLiteral::Integer(value, negative))
+            }
             Value::I32(value) => {
                 let negative = value < 0;
                 let value = value.abs();
@@ -102,6 +112,9 @@ impl Value {
             Value::U8(value) => {
                 HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
             }
+            Value::U16(value) => {
+                HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
+            }
             Value::U32(value) => {
                 HirExpression::Literal(HirLiteral::Integer((value as u128).into(), false))
             }

compiler/noirc_frontend/src/parser/parser.rs

@@ -47,7 +47,7 @@
 
 use chumsky::prelude::*;
 use iter_extended::vecmap;
 use lalrpop_util::lalrpop_mod;
 use noirc_errors::{Span, Spanned};
 
 mod assertion;
@@ -60,8 +60,8 @@
 mod structs;
 mod traits;
 
 // synthesized by LALRPOP
 lalrpop_mod!(pub noir_parser);
 
 #[cfg(test)]
 mod test_helpers;
@@ -85,12 +85,12 @@
 
     if cfg!(feature = "experimental_parser") {
         for parsed_item in &parsed_module.items {
             if lalrpop_parser_supports_kind(&parsed_item.kind) {
                 match &parsed_item.kind {
                     ItemKind::Import(parsed_use_tree) => {
                         prototype_parse_use_tree(Some(parsed_use_tree), source_program);
                     }
                     // other kinds prevented by lalrpop_parser_supports_kind
                     _ => unreachable!(),
                 }
             }
@@ -107,7 +107,7 @@
     }
 
     let mut lexer = Lexer::new(input);
     lexer = lexer.skip_whitespaces(false);
     let mut errors = Vec::new();
 
     // NOTE: this is a hack to get the references working
@@ -1374,7 +1374,7 @@
                 fresh_statement(),
                 true,
             ),
-            vec!["x as u8", "0 as Field", "(x + 3) as [Field; 8]"],
+            vec!["x as u8", "x as u16", "0 as Field", "(x + 3) as [Field; 8]"],
         );
         parse_all_failing(
             atom_or_right_unary(
@@ -1546,7 +1546,10 @@
         // Let statements are not type checked here, so the parser will accept as
         // long as it is a type. Other statements such as Public are type checked
         // Because for now, they can only have one type
-        parse_all(declaration(expression()), vec!["let _ = 42", "let x = y", "let x : u8 = y"]);
+        parse_all(
+            declaration(expression()),
+            vec!["let _ = 42", "let x = y", "let x : u8 = y", "let x: u16 = y"],
+        );
     }
 
     #[test]

docs/docs/noir/concepts/data_types/integers.md

@@ -5,7 +5,9 @@ keywords: [noir, integer types, methods, examples, arithmetic]
 sidebar_position: 1
 ---
 
-An integer type is a range constrained field type. The Noir frontend supports both unsigned and signed integer types. The allowed sizes are 1, 8, 32 and 64 bits.
+An integer type is a range constrained field type.
+The Noir frontend supports both unsigned and signed integer types.
+The allowed sizes are 1, 8, 16, 32 and 64 bits.
 
 :::info
 

test_programs/execution_success/u16_support/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "u16_support"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.29.0"
+
+[dependencies]

test_programs/execution_success/u16_support/Prover.toml

@@ -0,0 +1 @@
+x = "2"

test_programs/execution_success/u16_support/src/main.nr

@@ -0,0 +1,24 @@
+fn main(x: u16) {
+    test_u16(x);
+    test_u16_unconstrained(x);
+}
+
+unconstrained fn test_u16_unconstrained(x: u16) {
+    test_u16(x)
+}
+
+fn test_u16(x: u16) {
+    let t1: u16 = 1234;
+    let t2: u16 = 4321;
+    let t = t1 + t2;
+
+    let t4 = t - t2;
+    assert(t4 == t1);
+
+    let mut small_int = x as u16;
+    let shift = small_int << (x as u8);
+    assert(shift == 8);
+    assert(shift >> (x as u8) == small_int);
+    assert(shift >> 15 == 0);
+    assert(shift << 15 == 0);
+}