Add string parsing and a print builtin (#721)

It was in my mind to add String in order to support libraries in `package`.  `print` is added in order to have a String go to stdout. I've tried to do `print` in a way that won't be too hard to add other printable types, but it's probably also somewhat optional here -- that is, if desired, I could remove it. But it was a lot easier to doublecheck `\n` behavior with it, and I suspect it'll be helpful in other tests if it supports more value types.

On the side, this also fixes dereferencing in Pattern/Expression Print() calls, which I was noticing printing pointers instead of values. This may be another argument for moving away from passing pointers, since this seems to be a difficult-to-catch error.

Co-authored-by: Geoff Romer <gromer@google.com>

executable_semantics/syntax/BUILD

@@ -31,6 +31,7 @@ cc_library(
         ":paren_contents",
         "//common:check",
         "//common:ostream",
+        "//common:string_helpers",
         "//executable_semantics/ast:declaration",
         "//executable_semantics/ast:expression",
         "//executable_semantics/common:arena",

executable_semantics/syntax/lexer.lpp

@@ -8,6 +8,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <cstdlib>
 
 #include "common/check.h"
+#include "common/string_helpers.h"
 #include "executable_semantics/common/tracing_flag.h"
 #include "executable_semantics/syntax/parse_and_lex_context.h"
 #include "llvm/ADT/StringExtras.h"
@@ -49,6 +50,7 @@ MATCH             "match"
 NOT               "not"
 OR                "or"
 RETURN            "return"
+STRING            "String"
 STRUCT            "struct"
 TRUE              "true"
 TYPE              "Type"
@@ -63,6 +65,7 @@ UNDERSCORE        "_"
 identifier    [A-Za-z_][A-Za-z0-9_]*
 sized_type_literal [iuf][1-9][0-9]*
 integer_literal   [0-9]+
+string_literal    \"([^\\\"\n]|\\.)*\"
 horizontal_whitespace [ \t\r]
 whitespace [ \t\r\n]
 operand_start [(A-Za-z0-9_"]
@@ -120,6 +123,7 @@ operand_start [(A-Za-z0-9_"]
 {RUN}      { return Carbon::Parser::make_RUN(context.current_token_position); }
 {AWAIT}    { return Carbon::Parser::make_AWAIT(context.current_token_position); }
 {UNDERSCORE}      { return Carbon::Parser::make_UNDERSCORE(context.current_token_position); }
+{STRING}   { return Carbon::Parser::make_STRING(context.current_token_position); }
 
 {sized_type_literal} { return Carbon::Parser::make_sized_type_literal(yytext, context.current_token_position); }
 
@@ -189,6 +193,23 @@ operator and its operand, leading to three more cases:
   return Carbon::Parser::make_integer_literal(val, context.current_token_position);
 }
 
+{string_literal} {
+  llvm::StringRef str(yytext);
+  CHECK(str.consume_front("\"") && str.consume_back("\""));
+  std::optional<std::string> unescaped = Carbon::UnescapeStringLiteral(str);
+  if (unescaped == std::nullopt) {
+    if (Carbon::tracing_output) {
+      // Print a newline because tracing prints an incomplete line
+      // "Reading a token: ".
+      llvm::errs() << "\n";
+    }
+    FATAL_COMPILATION_ERROR(yylineno)
+        << "Invalid escaping in string: " << yytext;
+  }
+  return Carbon::Parser::make_string_literal(
+      *unescaped, context.current_token_position);
+}
+
 {ONE_LINE_COMMENT} {
   // Advance end by 1 line, resetting the column to zero.
   context.current_token_position.lines(1);

executable_semantics/syntax/parse_and_lex_context.cpp

@@ -4,12 +4,16 @@
 
 #include "executable_semantics/syntax/parse_and_lex_context.h"
 
+namespace Carbon {
+
 // Writes a syntax error diagnostic, containing message, for the input file at
 // the given line, to standard error.
-auto Carbon::ParseAndLexContext::PrintDiagnostic(const std::string& message,
-                                                 int line_num) -> void {
+auto ParseAndLexContext::PrintDiagnostic(const std::string& message,
+                                         int line_num) -> void {
   // TODO: Do we really want this to be fatal?  It makes the comment and the
   // name a lie, and renders some of the other yyparse() result propagation code
   // moot.
   FATAL_COMPILATION_ERROR(line_num) << message;
 }
+
+}  // namespace Carbon

executable_semantics/syntax/parser.ypp

@@ -90,6 +90,7 @@ void Carbon::Parser::error(const location_type&, const std::string& message) {
 %token <int> integer_literal
 %token <std::string> identifier
 %token <std::string> sized_type_literal
+%token <std::string> string_literal
 %type <std::string> designator
 %type <const Declaration*> declaration
 %type <FunctionDefinition> function_declaration
@@ -131,6 +132,7 @@ void Carbon::Parser::error(const location_type&, const std::string& message) {
 %token AND
 %token OR
 %token NOT
+%token STRING
 %token BOOL
 %token TYPE
 %token FN
@@ -218,6 +220,8 @@ expression:
     { $$ = global_arena->New<IndexExpression>(yylineno, $1, $3); }
 | integer_literal
     { $$ = global_arena->New<IntLiteral>(yylineno, $1); }
+| string_literal
+    { $$ = global_arena->New<StringLiteral>(yylineno, $1); }
 | TRUE
     { $$ = global_arena->New<BoolLiteral>(yylineno, true); }
 | FALSE
@@ -229,6 +233,8 @@ expression:
       CHECK($1[0] == 'i' && val == 32)  << "Only i32 is supported for now: " << $1;
       $$ = global_arena->New<IntTypeLiteral>(yylineno);
     }
+| STRING
+    { $$ = global_arena->New<StringTypeLiteral>(yylineno); }
 | BOOL
     { $$ = global_arena->New<BoolTypeLiteral>(yylineno); }
 | TYPE

executable_semantics/syntax/syntax_helpers.cpp

@@ -4,6 +4,7 @@
 
 #include "executable_semantics/syntax/syntax_helpers.h"
 
+#include "common/check.h"
 #include "common/ostream.h"
 #include "executable_semantics/common/arena.h"
 #include "executable_semantics/common/tracing_flag.h"
@@ -12,7 +13,29 @@
 
 namespace Carbon {
 
-void ExecProgram(const std::list<const Declaration*>& fs) {
+// Adds builtins, currently only Print(). Note Print() is experimental, not
+// standardized, but is made available for printing state in tests.
+static void AddIntrinsics(std::list<const Declaration*>* fs) {
+  std::vector<TuplePattern::Field> print_fields = {TuplePattern::Field(
+      "0", global_arena->New<BindingPattern>(
+               -1, "format_str",
+               global_arena->New<ExpressionPattern>(
+                   global_arena->New<StringTypeLiteral>(-1))))};
+  auto* print_return =
+      global_arena->New<Return>(-1,
+                                global_arena->New<IntrinsicExpression>(
+                                    IntrinsicExpression::IntrinsicKind::Print),
+                                false);
+  auto* print = global_arena->New<FunctionDeclaration>(FunctionDefinition(
+      -1, "Print", std::vector<GenericBinding>(),
+      global_arena->New<TuplePattern>(-1, print_fields),
+      global_arena->New<ExpressionPattern>(global_arena->New<TupleLiteral>(-1)),
+      /*is_omitted_return_type=*/false, print_return));
+  fs->insert(fs->begin(), print);
+}
+
+void ExecProgram(std::list<const Declaration*> fs) {
+  AddIntrinsics(&fs);
   if (tracing_output) {
     llvm::outs() << "********** source program **********\n";
     for (const auto* decl : fs) {

executable_semantics/syntax/syntax_helpers.h

@@ -16,7 +16,7 @@
 namespace Carbon {
 
 // Runs the top-level declaration list.
-void ExecProgram(const std::list<const Declaration*>& fs);
+void ExecProgram(std::list<const Declaration*> fs);
 
 }  // namespace Carbon