Support user-defined implicit conversions via ImplicitAs

explorer/ast/ast_rtti.txt

@@ -54,6 +54,7 @@ abstract class Expression : AstNode;
   class StructLiteral : Expression;
   class StructTypeLiteral : Expression;
   class TypeTypeLiteral : Expression;
+  class ValueLiteral : Expression;
   class IdentifierExpression : Expression;
   class IntrinsicExpression : Expression;
   class IfExpression : Expression;

explorer/ast/declaration.h

@@ -295,6 +295,12 @@ class VariableDeclaration : public Declaration {
 
   auto has_initializer() const -> bool { return initializer_.has_value(); }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_initializer(Nonnull<Expression*> initializer) {
+    CARBON_CHECK(has_initializer()) << "should not add a new initializer";
+    initializer_ = initializer;
+  }
+
  private:
   // TODO: split this into a non-optional name and a type, initialized by
   // a constructor that takes a BindingPattern and handles errors like a

explorer/ast/expression.cpp

@@ -200,6 +200,7 @@ void Expression::Print(llvm::raw_ostream& out) const {
     case ExpressionKind::StringTypeLiteral:
     case ExpressionKind::TypeTypeLiteral:
     case ExpressionKind::ContinuationTypeLiteral:
+    case ExpressionKind::ValueLiteral:
       PrintID(out);
       break;
   }
@@ -236,6 +237,10 @@ void Expression::PrintID(llvm::raw_ostream& out) const {
     case ExpressionKind::ContinuationTypeLiteral:
       out << "Continuation";
       break;
+    case ExpressionKind::ValueLiteral:
+      // FIXME: For layering reasons, we can't print out the value from here.
+      out << "ValueLiteral";
+      break;
     case ExpressionKind::IndexExpression:
     case ExpressionKind::FieldAccessExpression:
     case ExpressionKind::CompoundFieldAccessExpression:

explorer/ast/expression.h

@@ -70,6 +70,12 @@ class Expression : public AstNode {
     value_category_ = value_category;
   }
 
+  // Determines whether the expression has already been type-checked. Should
+  // only be used by type-checking.
+  auto is_type_checked() -> bool {
+    return static_type_.has_value() && value_category_.has_value();
+  }
+
  protected:
   // Constructs an Expression representing syntax at the given line number.
   // `kind` must be the enumerator corresponding to the most-derived type being
@@ -238,6 +244,9 @@ class CompoundFieldAccessExpression : public Expression {
     impl_ = impl;
   }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_object(Nonnull<Expression*> object) { object_ = object; }
+
  private:
   Nonnull<Expression*> object_;
   Nonnull<Expression*> path_;
@@ -467,6 +476,9 @@ class CallExpression : public Expression {
     deduced_args_ = deduced_args;
   }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_argument(Nonnull<Expression*> argument) { argument_ = argument; }
+
  private:
   Nonnull<Expression*> function_;
   Nonnull<Expression*> argument_;
@@ -537,6 +549,29 @@ class TypeTypeLiteral : public Expression {
   }
 };
 
+// A literal value. This is used in desugaring, and can't be expressed in
+// source syntax.
+class ValueLiteral : public Expression {
+ public:
+  // Value literals are created by type-checking, and so are created with their
+  // type and value category already known.
+  ValueLiteral(SourceLocation source_loc, Nonnull<const Value*> value,
+               Nonnull<const Value*> type, ValueCategory value_category)
+      : Expression(AstNodeKind::ValueLiteral, source_loc), value_(value) {
+    set_static_type(type);
+    set_value_category(value_category);
+  }
+
+  static auto classof(const AstNode* node) -> bool {
+    return InheritsFromValueLiteral(node->kind());
+  }
+
+  auto value() const -> const Value& { return *value_; }
+
+ private:
+  Nonnull<const Value*> value_;
+};
+
 class IntrinsicExpression : public Expression {
  public:
   enum class Intrinsic {
@@ -595,6 +630,9 @@ class IfExpression : public Expression {
   }
   auto else_expression() -> Expression& { return *else_expression_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_condition(Nonnull<Expression*> condition) { condition_ = condition; }
+
  private:
   Nonnull<Expression*> condition_;
   Nonnull<Expression*> then_expression_;

explorer/ast/statement.h

@@ -101,6 +101,9 @@ class Assign : public Statement {
   auto rhs() const -> const Expression& { return *rhs_; }
   auto rhs() -> Expression& { return *rhs_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_rhs(Nonnull<Expression*> rhs) { rhs_ = rhs; }
+
  private:
   Nonnull<Expression*> lhs_;
   Nonnull<Expression*> rhs_;
@@ -125,6 +128,9 @@ class VariableDefinition : public Statement {
   auto init() -> Expression& { return *init_; }
   auto value_category() const -> ValueCategory { return value_category_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_init(Nonnull<Expression*> init) { init_ = init; }
+
  private:
   Nonnull<Pattern*> pattern_;
   Nonnull<Expression*> init_;
@@ -153,6 +159,9 @@ class If : public Statement {
   }
   auto else_block() -> std::optional<Nonnull<Block*>> { return else_block_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_condition(Nonnull<Expression*> condition) { condition_ = condition; }
+
  private:
   Nonnull<Expression*> condition_;
   Nonnull<Block*> then_block_;
@@ -186,6 +195,11 @@ class Return : public Statement {
   auto function() const -> const FunctionDeclaration& { return **function_; }
   auto function() -> FunctionDeclaration& { return **function_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_expression(Nonnull<Expression*> expression) {
+    expression_ = expression;
+  }
+
   // Can only be called once, by ResolveControlFlow.
   void set_function(Nonnull<FunctionDeclaration*> function) {
     CARBON_CHECK(!function_.has_value());
@@ -215,6 +229,9 @@ class While : public Statement {
   auto body() const -> const Block& { return *body_; }
   auto body() -> Block& { return *body_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_condition(Nonnull<Expression*> condition) { condition_ = condition; }
+
  private:
   Nonnull<Expression*> condition_;
   Nonnull<Block*> body_;
@@ -306,6 +323,11 @@ class Match : public Statement {
   auto clauses() const -> llvm::ArrayRef<Clause> { return clauses_; }
   auto clauses() -> llvm::MutableArrayRef<Clause> { return clauses_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_expression(Nonnull<Expression*> expression) {
+    expression_ = expression;
+  }
+
  private:
   Nonnull<Expression*> expression_;
   std::vector<Clause> clauses_;
@@ -376,6 +398,9 @@ class Run : public Statement {
   auto argument() const -> const Expression& { return *argument_; }
   auto argument() -> Expression& { return *argument_; }
 
+  // Can only be called by type-checking, if a conversion was required.
+  void set_argument(Nonnull<Expression*> argument) { argument_ = argument; }
+
  private:
   Nonnull<Expression*> argument_;
 };

explorer/data/prelude.carbon

@@ -4,6 +4,36 @@
 
 package Carbon api;
 
+// Implicitly convert `Self` to `T`.
+interface ImplicitAs(T:! Type) {
+  fn Convert[me: Self]() -> T;
+}
+
+// TODO: Simplify this once we have variadics.
+// TODO: Should these be final?
+impl forall [U1:! Type, T1:! ImplicitAs(U1)]
+    (T1,) as ImplicitAs((U1,)) {
+  fn Convert[me: Self]() -> (U1,) {
+    let (v1: T1,) = me;
+    return (v1.Convert(),);
+  }
+}
+impl forall [U1:! Type, U2:! Type, T1:! ImplicitAs(U1), T2:! ImplicitAs(U2)]
+    (T1, T2) as ImplicitAs((U1, U2)) {
+  fn Convert[me: Self]() -> (U1, U2) {
+    let (v1: T1, v2: T2) = me;
+    return (v1.Convert(), v2.Convert());
+  }
+}
+impl forall [U1:! Type, U2:! Type, U3:! Type,
+             T1:! ImplicitAs(U1), T2:! ImplicitAs(U2), T3:! ImplicitAs(U3)]
+    (T1, T2, T3) as ImplicitAs((U1, U2, U3)) {
+  fn Convert[me: Self]() -> (U1, U2, U3) {
+    let (v1: T1, v2: T2, v3: T3) = me;
+    return (v1.Convert(), v2.Convert(), v3.Convert());
+  }
+}
+
 // Note that Print is experimental, and not part of an accepted proposal, but
 // is included here for printing state in tests.
 fn Print(format_str: String) {

explorer/fuzzing/ast_to_proto.cpp

@@ -80,8 +80,9 @@ static auto ExpressionToProto(const Expression& expression)
     -> Fuzzing::Expression {
   Fuzzing::Expression expression_proto;
   switch (expression.kind()) {
-    case ExpressionKind::InstantiateImpl: {
-      // UNDER CONSTRUCTION
+    case ExpressionKind::InstantiateImpl:
+    case ExpressionKind::ValueLiteral: {
+      // These do not correspond to source syntax.
       break;
     }
     case ExpressionKind::CallExpression: {

explorer/interpreter/BUILD

@@ -192,17 +192,20 @@ cc_library(
 cc_library(
     name = "type_checker",
     srcs = [
+        "builtins.cpp",
         "impl_scope.cpp",
         "type_checker.cpp",
     ],
     hdrs = [
+        "builtins.h",
         "impl_scope.h",
         "type_checker.h",
     ],
     deps = [
         ":action_and_value",
         ":dictionary",
         ":interpreter",
+        "//common:error",
         "//common:ostream",
         "//explorer/ast",
         "//explorer/ast:declaration",
@@ -211,6 +214,7 @@ cc_library(
         "//explorer/common:arena",
         "//explorer/common:error_builders",
         "//explorer/common:nonnull",
+        "//explorer/common:source_location",
         "@llvm-project//llvm:Support",
     ],
 )

explorer/interpreter/builtins.cpp

@@ -0,0 +1,32 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "explorer/interpreter/builtins.h"
+
+#include "explorer/common/error_builders.h"
+
+using llvm::dyn_cast;
+
+namespace Carbon {
+
+void Builtins::Register(Nonnull<const Declaration*> decl) {
+  if (auto* interface = dyn_cast<InterfaceDeclaration>(decl)) {
+    if (interface->name() == GetName(Builtin::ImplicitAs)) {
+      builtins_[static_cast<int>(Builtin::ImplicitAs)] = interface;
+    }
+  }
+}
+
+auto Builtins::Get(SourceLocation source_loc, Builtin builtin) const
+    -> ErrorOr<Nonnull<const Declaration*>> {
+  std::optional<const Declaration*> result =
+      builtins_[static_cast<int>(builtin)];
+  if (!result.has_value()) {
+    return CompilationError(source_loc)
+           << "missing declaration for builtin `" << GetName(builtin) << "`";
+  }
+  return result.value();
+}
+
+}  // namespace Carbon

explorer/interpreter/builtins.h

@@ -0,0 +1,48 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef CARBON_EXPLORER_INTERPRETER_BUILTINS_H_
+#define CARBON_EXPLORER_INTERPRETER_BUILTINS_H_
+
+#include <optional>
+
+#include "common/error.h"
+#include "explorer/ast/declaration.h"
+#include "explorer/ast/expression.h"
+#include "explorer/common/nonnull.h"
+#include "explorer/common/source_location.h"
+#include "explorer/interpreter/value.h"
+
+namespace Carbon {
+
+class Builtins {
+ public:
+  explicit Builtins() {}
+
+  enum class Builtin { ImplicitAs, Last = ImplicitAs };
+  // FIXME: In C++20, replace with `using enum Builtin;`.
+  static constexpr Builtin ImplicitAs = Builtin::ImplicitAs;
+
+  // Register a declaration that might be a builtin.
+  void Register(Nonnull<const Declaration*> decl);
+
+  // Get a registered builtin.
+  auto Get(SourceLocation source_loc, Builtin builtin) const
+      -> ErrorOr<Nonnull<const Declaration*>>;
+
+  // Get the source name of a builtin.
+  static constexpr auto GetName(Builtin builtin) -> const char* {
+    return BuiltinNames[static_cast<int>(builtin)];
+  }
+
+ private:
+  static constexpr int NumBuiltins = static_cast<int>(Builtin::Last) + 1;
+  static constexpr const char* BuiltinNames[NumBuiltins] = {"ImplicitAs"};
+
+  std::optional<Nonnull<const Declaration*>> builtins_[NumBuiltins] = {};
+};
+
+}  // namespace Carbon
+
+#endif  // CARBON_EXPLORER_INTERPRETER_BUILTINS_H_

explorer/interpreter/interpreter.cpp

@@ -401,6 +401,7 @@ auto Interpreter::StepLvalue() -> ErrorOr<Success> {
     case ExpressionKind::ContinuationTypeLiteral:
     case ExpressionKind::StringLiteral:
     case ExpressionKind::StringTypeLiteral:
+    case ExpressionKind::ValueLiteral:
     case ExpressionKind::IntrinsicExpression:
     case ExpressionKind::IfExpression:
     case ExpressionKind::ArrayTypeLiteral:
@@ -1042,6 +1043,10 @@ auto Interpreter::StepExp() -> ErrorOr<Success> {
       CARBON_CHECK(act.pos() == 0);
       return todo_.FinishAction(arena_->New<StringType>());
     }
+    case ExpressionKind::ValueLiteral: {
+      CARBON_CHECK(act.pos() == 0);
+      return todo_.FinishAction(&cast<ValueLiteral>(exp).value());
+    }
     case ExpressionKind::IfExpression: {
       const auto& if_expr = cast<IfExpression>(exp);
       if (act.pos() == 0) {

explorer/interpreter/resolve_names.cpp

@@ -191,6 +191,7 @@ static auto ResolveNames(Expression& expression,
     case ExpressionKind::StringLiteral:
     case ExpressionKind::StringTypeLiteral:
     case ExpressionKind::TypeTypeLiteral:
+    case ExpressionKind::ValueLiteral:
       break;
     case ExpressionKind::InstantiateImpl:  // created after name resolution
     case ExpressionKind::UnimplementedExpression: