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/ast/expression.cpp

@@ -67,7 +67,7 @@ static void PrintFields(llvm::raw_ostream& out,
                         const std::vector<FieldInitializer>& fields) {
   llvm::ListSeparator sep;
   for (const auto& field : fields) {
-    out << sep << field.name << " = " << field.expression;
+    out << sep << field.name << " = " << *field.expression;
   }
 }
 
@@ -129,6 +129,14 @@ void Expression::Print(llvm::raw_ostream& out) const {
     case Expression::Kind::IntTypeLiteral:
       out << "i32";
       break;
+    case Expression::Kind::StringLiteral:
+      out << "\"";
+      out.write_escaped(cast<StringLiteral>(*this).Val());
+      out << "\"";
+      break;
+    case Expression::Kind::StringTypeLiteral:
+      out << "String";
+      break;
     case Expression::Kind::TypeTypeLiteral:
       out << "Type";
       break;
@@ -140,6 +148,13 @@ void Expression::Print(llvm::raw_ostream& out) const {
       out << "fn " << *fn.Parameter() << " -> " << *fn.ReturnType();
       break;
     }
+    case Expression::Kind::IntrinsicExpression:
+      out << "intrinsic_expression(";
+      switch (cast<IntrinsicExpression>(*this).Intrinsic()) {
+        case IntrinsicExpression::IntrinsicKind::Print:
+          out << "print";
+      }
+      out << ")";
   }
 }
 

executable_semantics/ast/expression.h

@@ -29,9 +29,12 @@ class Expression {
     ContinuationTypeLiteral,  // The type of a continuation value.
     IntLiteral,
     PrimitiveOperatorExpression,
+    StringLiteral,
+    StringTypeLiteral,
     TupleLiteral,
     TypeTypeLiteral,
     IdentifierExpression,
+    IntrinsicExpression,
   };
 
   // Returns the enumerator corresponding to the most-derived type of this
@@ -178,6 +181,31 @@ class BoolLiteral : public Expression {
   bool val;
 };
 
+class StringLiteral : public Expression {
+ public:
+  explicit StringLiteral(int line_num, std::string val)
+      : Expression(Kind::StringLiteral, line_num), val(std::move(val)) {}
+
+  static auto classof(const Expression* exp) -> bool {
+    return exp->Tag() == Kind::StringLiteral;
+  }
+
+  auto Val() const -> const std::string& { return val; }
+
+ private:
+  std::string val;
+};
+
+class StringTypeLiteral : public Expression {
+ public:
+  explicit StringTypeLiteral(int line_num)
+      : Expression(Kind::StringTypeLiteral, line_num) {}
+
+  static auto classof(const Expression* exp) -> bool {
+    return exp->Tag() == Kind::StringTypeLiteral;
+  }
+};
+
 class TupleLiteral : public Expression {
  public:
   explicit TupleLiteral(int line_num) : TupleLiteral(line_num, {}) {}
@@ -301,6 +329,25 @@ class TypeTypeLiteral : public Expression {
   }
 };
 
+class IntrinsicExpression : public Expression {
+ public:
+  enum class IntrinsicKind {
+    Print,
+  };
+
+  explicit IntrinsicExpression(IntrinsicKind intrinsic)
+      : Expression(Kind::IntrinsicExpression, -1), intrinsic(intrinsic) {}
+
+  static auto classof(const Expression* exp) -> bool {
+    return exp->Tag() == Kind::IntrinsicExpression;
+  }
+
+  auto Intrinsic() const -> IntrinsicKind { return intrinsic; }
+
+ private:
+  IntrinsicKind intrinsic;
+};
+
 }  // namespace Carbon
 
 #endif  // EXECUTABLE_SEMANTICS_AST_EXPRESSION_H_

executable_semantics/ast/pattern.cpp

@@ -37,19 +37,19 @@ void Pattern::Print(llvm::raw_ostream& out) const {
       out << "(";
       llvm::ListSeparator sep;
       for (const TuplePattern::Field& field : tuple.Fields()) {
-        out << sep << field.name << " = " << field.pattern;
+        out << sep << field.name << " = " << *field.pattern;
       }
       out << ")";
       break;
     }
     case Kind::AlternativePattern: {
       const auto& alternative = cast<AlternativePattern>(*this);
-      out << alternative.ChoiceType() << "." << alternative.AlternativeName()
-          << alternative.Arguments();
+      out << *alternative.ChoiceType() << "." << alternative.AlternativeName()
+          << *alternative.Arguments();
       break;
     }
     case Kind::ExpressionPattern:
-      out << cast<ExpressionPattern>(*this).Expression();
+      out << *cast<ExpressionPattern>(*this).Expression();
       break;
   }
 }