From 8d560e66394de318f199d0921a2805c6f978a892 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 5 Jan 2021 17:49:01 +0000 Subject: [PATCH] Examine the Suffix hint on integers to apply apropriate TyTy type. This change propagates the PrimitiveCoreType to AST and HIR so the suffix can be examined. --- gcc/rust/ast/rust-ast-full-test.cc | 21 +++++---- gcc/rust/ast/rust-ast.h | 16 +++++-- gcc/rust/ast/rust-expr.h | 4 +- gcc/rust/ast/rust-pattern.h | 4 +- gcc/rust/backend/rust-compile-tyty.h | 24 ++++++++++ gcc/rust/hir/rust-ast-lower-expr.h | 1 + gcc/rust/hir/tree/rust-hir-expr.h | 5 ++- gcc/rust/hir/tree/rust-hir-full-test.cc | 37 ++-------------- gcc/rust/hir/tree/rust-hir-pattern.h | 4 +- gcc/rust/hir/tree/rust-hir.h | 16 ++++--- gcc/rust/parse/rust-parse-impl.h | 39 ++++++++++------ gcc/rust/resolve/rust-ast-resolve.cc | 12 +++++ gcc/rust/rust-session-manager.cc | 16 ++++--- gcc/rust/typecheck/rust-hir-type-check-expr.h | 44 +++++++++++++++++-- gcc/rust/typecheck/rust-tyty.cc | 8 ++++ gcc/rust/typecheck/rust-tyty.h | 4 ++ .../rust.test/compilable/integer_types.rs | 25 +++++++++++ 17 files changed, 197 insertions(+), 83 deletions(-) create mode 100644 gcc/testsuite/rust.test/compilable/integer_types.rs diff --git a/gcc/rust/ast/rust-ast-full-test.cc b/gcc/rust/ast/rust-ast-full-test.cc index 030b0b3707e4..5c1289e9579b 100644 --- a/gcc/rust/ast/rust-ast-full-test.cc +++ b/gcc/rust/ast/rust-ast-full-test.cc @@ -4940,28 +4940,30 @@ MacroParser::parse_literal () { case CHAR_LITERAL: skip_token (); - return Literal (tok->as_string (), Literal::CHAR); + return Literal (tok->as_string (), Literal::CHAR, tok->get_type_hint ()); case STRING_LITERAL: skip_token (); - return Literal (tok->as_string (), Literal::STRING); + return Literal (tok->as_string (), Literal::STRING, + tok->get_type_hint ()); case BYTE_CHAR_LITERAL: skip_token (); - return Literal (tok->as_string (), Literal::BYTE); + return Literal (tok->as_string (), Literal::BYTE, tok->get_type_hint ()); case BYTE_STRING_LITERAL: skip_token (); - return Literal (tok->as_string (), Literal::BYTE_STRING); + return Literal (tok->as_string (), Literal::BYTE_STRING, + tok->get_type_hint ()); case INT_LITERAL: skip_token (); - return Literal (tok->as_string (), Literal::INT); + return Literal (tok->as_string (), Literal::INT, tok->get_type_hint ()); case FLOAT_LITERAL: skip_token (); - return Literal (tok->as_string (), Literal::FLOAT); + return Literal (tok->as_string (), Literal::FLOAT, tok->get_type_hint ()); case TRUE_LITERAL: skip_token (); - return Literal ("true", Literal::BOOL); + return Literal ("true", Literal::BOOL, tok->get_type_hint ()); case FALSE_LITERAL: skip_token (); - return Literal ("false", Literal::BOOL); + return Literal ("false", Literal::BOOL, tok->get_type_hint ()); default: rust_error_at (tok->get_locus (), "expected literal - found '%s'", get_token_description (tok->get_id ())); @@ -5284,7 +5286,8 @@ Token::to_token_stream () const Attribute MetaNameValueStr::to_attribute () const { - LiteralExpr lit_expr (str, Literal::LitType::STRING, Location ()); + LiteralExpr lit_expr (str, Literal::LitType::STRING, + PrimitiveCoreType::CORETYPE_UNKNOWN, Location ()); return Attribute (SimplePath::from_str (ident), std::unique_ptr ( new AttrInputLiteral (std::move (lit_expr)))); diff --git a/gcc/rust/ast/rust-ast.h b/gcc/rust/ast/rust-ast.h index b26c77019109..941b2fe70f79 100644 --- a/gcc/rust/ast/rust-ast.h +++ b/gcc/rust/ast/rust-ast.h @@ -212,6 +212,8 @@ class Token : public TokenTree, public MacroMatch Location get_locus () const { return locus; } + PrimitiveCoreType get_type_hint () const { return type_hint; } + protected: // No virtual for now as not polymorphic but can be in future /*virtual*/ Token *clone_token_impl () const { return new Token (*this); } @@ -250,17 +252,25 @@ struct Literal * (or generics) */ std::string value_as_string; LitType type; + PrimitiveCoreType type_hint; public: std::string as_string () const { return value_as_string; } LitType get_lit_type () const { return type; } - Literal (std::string value_as_string, LitType type) - : value_as_string (std::move (value_as_string)), type (type) + PrimitiveCoreType get_type_hint () const { return type_hint; } + + Literal (std::string value_as_string, LitType type, + PrimitiveCoreType type_hint) + : value_as_string (std::move (value_as_string)), type (type), + type_hint (type_hint) {} - static Literal create_error () { return Literal ("", CHAR); } + static Literal create_error () + { + return Literal ("", CHAR, PrimitiveCoreType::CORETYPE_UNKNOWN); + } // Returns whether literal is in an invalid state. bool is_error () const { return value_as_string == ""; } diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h index cc874980afa1..7c5df41d0a9e 100644 --- a/gcc/rust/ast/rust-expr.h +++ b/gcc/rust/ast/rust-expr.h @@ -50,10 +50,10 @@ class LiteralExpr : public ExprWithoutBlock Literal::LitType get_lit_type () const { return literal.get_lit_type (); } LiteralExpr (std::string value_as_string, Literal::LitType type, - Location locus, + PrimitiveCoreType type_hint, Location locus, std::vector outer_attrs = std::vector ()) : ExprWithoutBlock (std::move (outer_attrs)), - literal (std::move (value_as_string), type), locus (locus) + literal (std::move (value_as_string), type, type_hint), locus (locus) {} LiteralExpr (Literal literal, Location locus, diff --git a/gcc/rust/ast/rust-pattern.h b/gcc/rust/ast/rust-pattern.h index 79beebb059e3..e89fc625677b 100644 --- a/gcc/rust/ast/rust-pattern.h +++ b/gcc/rust/ast/rust-pattern.h @@ -47,8 +47,8 @@ class LiteralPattern : public Pattern LiteralPattern (std::string val, Literal::LitType type, Location locus, bool has_minus = false) - : lit (Literal (std::move (val), type)), has_minus (has_minus), - locus (locus) + : lit (Literal (std::move (val), type, PrimitiveCoreType::CORETYPE_STR)), + has_minus (has_minus), locus (locus) {} Location get_locus () const { return locus; } diff --git a/gcc/rust/backend/rust-compile-tyty.h b/gcc/rust/backend/rust-compile-tyty.h index 66d2472265cc..f4e467a868eb 100644 --- a/gcc/rust/backend/rust-compile-tyty.h +++ b/gcc/rust/backend/rust-compile-tyty.h @@ -111,6 +111,18 @@ class TyTyCompile : public TyTy::TyVisitor = backend->named_type ("i32", backend->integer_type (false, 32), Linemap::predeclared_location ()); return; + + case TyTy::IntType::I64: + translated + = backend->named_type ("i64", backend->integer_type (false, 64), + Linemap::predeclared_location ()); + return; + + case TyTy::IntType::I128: + translated + = backend->named_type ("i128", backend->integer_type (false, 128), + Linemap::predeclared_location ()); + return; } gcc_unreachable (); } @@ -135,6 +147,18 @@ class TyTyCompile : public TyTy::TyVisitor = backend->named_type ("i32", backend->integer_type (true, 32), Linemap::predeclared_location ()); return; + + case TyTy::UintType::U64: + translated + = backend->named_type ("u64", backend->integer_type (true, 64), + Linemap::predeclared_location ()); + return; + + case TyTy::UintType::U128: + translated + = backend->named_type ("u128", backend->integer_type (true, 128), + Linemap::predeclared_location ()); + return; } gcc_unreachable (); } diff --git a/gcc/rust/hir/rust-ast-lower-expr.h b/gcc/rust/hir/rust-ast-lower-expr.h index a165eaf3c8a3..eb7fe1f3a379 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.h +++ b/gcc/rust/hir/rust-ast-lower-expr.h @@ -303,6 +303,7 @@ class ASTLoweringExpr : public ASTLoweringBase UNKNOWN_LOCAL_DEFID); translated = new HIR::LiteralExpr (mapping, expr.as_string (), type, + expr.get_literal ().get_type_hint (), expr.get_locus ()); } diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h index 1110f988dc76..00273c76cd78 100644 --- a/gcc/rust/hir/tree/rust-hir-expr.h +++ b/gcc/rust/hir/tree/rust-hir-expr.h @@ -66,10 +66,11 @@ class LiteralExpr : public ExprWithoutBlock Literal::LitType get_lit_type () const { return literal.get_lit_type (); } LiteralExpr (Analysis::NodeMapping mappings, std::string value_as_string, - Literal::LitType type, Location locus, + Literal::LitType type, PrimitiveCoreType type_hint, + Location locus, std::vector outer_attrs = std::vector ()) : ExprWithoutBlock (std::move (mappings), std::move (outer_attrs)), - literal (std::move (value_as_string), type), locus (locus) + literal (std::move (value_as_string), type, type_hint), locus (locus) {} LiteralExpr (Analysis::NodeMapping mappings, Literal literal, Location locus, diff --git a/gcc/rust/hir/tree/rust-hir-full-test.cc b/gcc/rust/hir/tree/rust-hir-full-test.cc index 2e30b594413d..900c6db9375c 100644 --- a/gcc/rust/hir/tree/rust-hir-full-test.cc +++ b/gcc/rust/hir/tree/rust-hir-full-test.cc @@ -4904,38 +4904,8 @@ DelimTokenTree::to_token_stream () const Literal MacroParser::parse_literal () { - const std::unique_ptr &tok = peek_token (); - switch (tok->get_id ()) - { - case CHAR_LITERAL: - skip_token (); - return Literal (tok->as_string (), Literal::CHAR); - case STRING_LITERAL: - skip_token (); - return Literal (tok->as_string (), Literal::STRING); - case BYTE_CHAR_LITERAL: - skip_token (); - return Literal (tok->as_string (), Literal::BYTE); - case BYTE_STRING_LITERAL: - skip_token (); - return Literal (tok->as_string (), Literal::BYTE_STRING); - case INT_LITERAL: - skip_token (); - return Literal (tok->as_string (), Literal::INT); - case FLOAT_LITERAL: - skip_token (); - return Literal (tok->as_string (), Literal::FLOAT); - case TRUE_LITERAL: - skip_token (); - return Literal ("true", Literal::BOOL); - case FALSE_LITERAL: - skip_token (); - return Literal ("false", Literal::BOOL); - default: - rust_error_at (tok->get_locus (), "expected literal - found '%s'", - get_token_description (tok->get_id ())); - return Literal::create_error (); - } + // marcos need to be removed from HIR + gcc_unreachable (); } SimplePath @@ -5037,7 +5007,8 @@ Attribute MetaNameValueStr::to_attribute () const { LiteralExpr lit_expr (Analysis::NodeMapping::get_error (), str, - Literal::LitType::STRING, Location ()); + Literal::LitType::STRING, + PrimitiveCoreType::CORETYPE_STR, Location ()); return Attribute (SimplePath::from_str (ident), std::unique_ptr ( new AttrInputLiteral (std::move (lit_expr)))); diff --git a/gcc/rust/hir/tree/rust-hir-pattern.h b/gcc/rust/hir/tree/rust-hir-pattern.h index 3ff13d27c3d0..d18d8db38066 100644 --- a/gcc/rust/hir/tree/rust-hir-pattern.h +++ b/gcc/rust/hir/tree/rust-hir-pattern.h @@ -47,8 +47,8 @@ class LiteralPattern : public Pattern LiteralPattern (std::string val, Literal::LitType type, Location locus, bool has_minus = false) - : lit (Literal (std::move (val), type)), has_minus (has_minus), - locus (locus) + : lit (Literal (std::move (val), type, PrimitiveCoreType::CORETYPE_STR)), + has_minus (has_minus), locus (locus) {} Location get_locus () const { return locus; } diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h index cbaa2e9ae667..7417a32d684c 100644 --- a/gcc/rust/hir/tree/rust-hir.h +++ b/gcc/rust/hir/tree/rust-hir.h @@ -235,21 +235,27 @@ struct Literal }; private: - /* TODO: maybe make subclasses of each type of literal with their typed values - * (or generics) */ std::string value_as_string; LitType type; + PrimitiveCoreType type_hint; public: std::string as_string () const { return value_as_string; } LitType get_lit_type () const { return type; } - Literal (std::string value_as_string, LitType type) - : value_as_string (std::move (value_as_string)), type (type) + PrimitiveCoreType get_type_hint () const { return type_hint; } + + Literal (std::string value_as_string, LitType type, + PrimitiveCoreType type_hint) + : value_as_string (std::move (value_as_string)), type (type), + type_hint (type_hint) {} - static Literal create_error () { return Literal ("", CHAR); } + static Literal create_error () + { + return Literal ("", CHAR, PrimitiveCoreType::CORETYPE_UNKNOWN); + } // Returns whether literal is in an invalid state. bool is_error () const { return value_as_string == ""; } diff --git a/gcc/rust/parse/rust-parse-impl.h b/gcc/rust/parse/rust-parse-impl.h index a58bff6a3b0a..f6bd0f61455e 100644 --- a/gcc/rust/parse/rust-parse-impl.h +++ b/gcc/rust/parse/rust-parse-impl.h @@ -791,7 +791,8 @@ Parser::parse_attr_input () } // create actual LiteralExpr - AST::LiteralExpr lit_expr (t->get_str (), lit_type, t->get_locus ()); + AST::LiteralExpr lit_expr (t->get_str (), lit_type, t->get_type_hint (), + t->get_locus ()); std::unique_ptr attr_input_lit ( new AST::AttrInputLiteral (std::move (lit_expr))); @@ -7374,7 +7375,8 @@ Parser::parse_literal_expr ( // create literal based on stuff in switch return std::unique_ptr ( new AST::LiteralExpr (std::move (literal_value), std::move (type), - t->get_locus (), std::move (outer_attrs))); + t->get_type_hint (), t->get_locus (), + std::move (outer_attrs))); } // Parses a return expression (including any expression to return). @@ -9954,7 +9956,8 @@ Parser::parse_literal_or_range_pattern () lexer.skip_token (); std::unique_ptr lower ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), type), + AST::Literal (range_lower->get_str (), type, + PrimitiveCoreType::CORETYPE_UNKNOWN), range_lower->get_locus (), has_minus)); std::unique_ptr upper @@ -9995,26 +9998,30 @@ Parser::parse_range_pattern_bound () lexer.skip_token (); return std::unique_ptr ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), AST::Literal::CHAR), + AST::Literal (range_lower->get_str (), AST::Literal::CHAR, + range_lower->get_type_hint ()), range_lower_locus)); case BYTE_CHAR_LITERAL: lexer.skip_token (); return std::unique_ptr ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), AST::Literal::BYTE), + AST::Literal (range_lower->get_str (), AST::Literal::BYTE, + range_lower->get_type_hint ()), range_lower_locus)); case INT_LITERAL: lexer.skip_token (); return std::unique_ptr ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), AST::Literal::INT), + AST::Literal (range_lower->get_str (), AST::Literal::INT, + range_lower->get_type_hint ()), range_lower_locus)); case FLOAT_LITERAL: lexer.skip_token (); fprintf (stderr, "warning: used deprecated float range pattern bound"); return std::unique_ptr ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), AST::Literal::FLOAT), + AST::Literal (range_lower->get_str (), AST::Literal::FLOAT, + range_lower->get_type_hint ()), range_lower_locus)); case MINUS: // branch on next token @@ -10025,7 +10032,8 @@ Parser::parse_range_pattern_bound () lexer.skip_token (1); return std::unique_ptr ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), AST::Literal::INT), + AST::Literal (range_lower->get_str (), AST::Literal::INT, + range_lower->get_type_hint ()), range_lower_locus, true)); case FLOAT_LITERAL: lexer.skip_token (1); @@ -10033,7 +10041,8 @@ Parser::parse_range_pattern_bound () "warning: used deprecated float range pattern bound"); return std::unique_ptr ( new AST::RangePatternBoundLiteral ( - AST::Literal (range_lower->get_str (), AST::Literal::FLOAT), + AST::Literal (range_lower->get_str (), AST::Literal::FLOAT, + range_lower->get_type_hint ()), range_lower_locus, true)); default: rust_error_at (range_lower->get_locus (), @@ -12110,22 +12119,24 @@ Parser::null_denotation ( // encode as int? return std::unique_ptr ( new AST::LiteralExpr (tok->get_str (), AST::Literal::INT, - tok->get_locus ())); + tok->get_type_hint (), tok->get_locus ())); case FLOAT_LITERAL: // encode as float? return std::unique_ptr ( new AST::LiteralExpr (tok->get_str (), AST::Literal::FLOAT, - tok->get_locus ())); + tok->get_type_hint (), tok->get_locus ())); case STRING_LITERAL: return std::unique_ptr ( new AST::LiteralExpr (tok->get_str (), AST::Literal::STRING, - tok->get_locus ())); + tok->get_type_hint (), tok->get_locus ())); case TRUE_LITERAL: return std::unique_ptr ( - new AST::LiteralExpr ("true", AST::Literal::BOOL, tok->get_locus ())); + new AST::LiteralExpr ("true", AST::Literal::BOOL, tok->get_type_hint (), + tok->get_locus ())); case FALSE_LITERAL: return std::unique_ptr ( - new AST::LiteralExpr ("false", AST::Literal::BOOL, tok->get_locus ())); + new AST::LiteralExpr ("false", AST::Literal::BOOL, + tok->get_type_hint (), tok->get_locus ())); case LEFT_PAREN: { // have to parse whole expression if inside brackets /* recursively invoke parse_expression with lowest priority possible as * it it were a top-level expression. */ diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc index 8370a5b97e0b..7970363b5bb7 100644 --- a/gcc/rust/resolve/rust-ast-resolve.cc +++ b/gcc/rust/resolve/rust-ast-resolve.cc @@ -126,19 +126,31 @@ Resolver::generate_builtins () = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U16); auto u32 = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U32); + auto u64 + = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U64); + auto u128 + = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U128); auto i8 = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I8); auto i16 = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I16); auto i32 = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I32); + auto i64 + = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I64); + auto i128 + = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I128); auto rbool = new TyTy::BoolType (mappings->get_next_hir_id ()); MKBUILTIN_TYPE ("u8", builtins, u8); MKBUILTIN_TYPE ("u16", builtins, u16); MKBUILTIN_TYPE ("u32", builtins, u32); + MKBUILTIN_TYPE ("u64", builtins, u64); + MKBUILTIN_TYPE ("u128", builtins, u128); MKBUILTIN_TYPE ("i8", builtins, i8); MKBUILTIN_TYPE ("i16", builtins, i16); MKBUILTIN_TYPE ("i32", builtins, i32); + MKBUILTIN_TYPE ("i64", builtins, i64); + MKBUILTIN_TYPE ("i128", builtins, i128); MKBUILTIN_TYPE ("bool", builtins, rbool); } diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 17ff24ae5d79..c1df913fbfe1 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -359,9 +359,10 @@ Session::enable_dump (std::string arg) * created */ if (arg == "all") { - rust_error_at (Location (), - "dumping all is not supported as of now. choose %, %, " - "or %"); + rust_error_at ( + Location (), + "dumping all is not supported as of now. choose %, %, " + "or %"); return false; } else if (arg == "lex") @@ -409,10 +410,11 @@ Session::enable_dump (std::string arg) } else { - rust_error_at (Location (), - "dump option %qs was unrecognised. choose %, %, or " - "%", - arg.c_str ()); + rust_error_at ( + Location (), + "dump option %qs was unrecognised. choose %, %, or " + "%", + arg.c_str ()); return false; } return true; diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h index 116fab7f2fb8..01b0934c16e8 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.h +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h @@ -152,10 +152,46 @@ class TypeCheckExpr : public TypeCheckBase switch (expr.get_lit_type ()) { case HIR::Literal::LitType::INT: { - // FIXME: - // assume i32 let the combiner functions figure it out - // this should look at the suffix of the literal value to check - auto ok = context->lookup_builtin ("i32", &infered); + bool ok = false; + + switch (expr.get_literal ()->get_type_hint ()) + { + case CORETYPE_I8: + ok = context->lookup_builtin ("i8", &infered); + break; + case CORETYPE_I16: + ok = context->lookup_builtin ("i16", &infered); + break; + case CORETYPE_I32: + ok = context->lookup_builtin ("i32", &infered); + break; + case CORETYPE_I64: + ok = context->lookup_builtin ("i64", &infered); + break; + case CORETYPE_I128: + ok = context->lookup_builtin ("i128", &infered); + break; + + case CORETYPE_U8: + ok = context->lookup_builtin ("u8", &infered); + break; + case CORETYPE_U16: + ok = context->lookup_builtin ("u16", &infered); + break; + case CORETYPE_U32: + ok = context->lookup_builtin ("u32", &infered); + break; + case CORETYPE_U64: + ok = context->lookup_builtin ("u64", &infered); + break; + case CORETYPE_U128: + ok = context->lookup_builtin ("u128", &infered); + break; + + default: + ok = context->lookup_builtin ("i32", &infered); + break; + } rust_assert (ok); } break; diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index 2023523ccddc..201a2f22cf8a 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -164,6 +164,10 @@ IntType::as_string () const return "i16"; case I32: return "i32"; + case I64: + return "i64"; + case I128: + return "i128"; } gcc_unreachable (); return "__unknown_int_type"; @@ -193,6 +197,10 @@ UintType::as_string () const return "u16"; case U32: return "u32"; + case U64: + return "u64"; + case U128: + return "u128"; } gcc_unreachable (); return "__unknown_uint_type"; diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index b9dc268722c4..d049f05bba7f 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -185,6 +185,8 @@ class IntType : public TyBase I8, I16, I32, + I64, + I128 }; IntType (HirId ref, IntKind kind) @@ -211,6 +213,8 @@ class UintType : public TyBase U8, U16, U32, + U64, + U128 }; UintType (HirId ref, UintKind kind) diff --git a/gcc/testsuite/rust.test/compilable/integer_types.rs b/gcc/testsuite/rust.test/compilable/integer_types.rs new file mode 100644 index 000000000000..22a916450bad --- /dev/null +++ b/gcc/testsuite/rust.test/compilable/integer_types.rs @@ -0,0 +1,25 @@ +fn main() { + let a1: i8 = 1i8; + let a2: i16 = 2i16; + let a3: i32 = 3i32; + let a4: i64 = 4i64; + let a5: i128 = 5i128; + + let b1 = 1i8; + let b2 = 2i16; + let b3 = 3i32; + let b4 = 4i64; + let b5 = 5i128; + + let c1: u8 = 1u8; + let c2: u16 = 2u16; + let c3: u32 = 3u32; + let c4: u64 = 4u64; + let c5: u128 = 5u128; + + let d1 = 1u8; + let d2 = 2u16; + let d3 = 3u32; + let d4 = 4u64; + let d5 = 5u128; +}