Merge pull request swiftlang#64090 from gottesmm/reference-bindings

[reference-binding] InOut Prototype

Author: gottesmm

include/swift/AST/DiagnosticsParse.def

@@ -964,6 +964,9 @@ ERROR(no_default_arg_closure,none,
 ERROR(no_default_arg_curried,none,
       "default arguments are not allowed in curried parameter lists", ())
 ERROR(var_pattern_in_var,none,
+      "'%select{let||var}0' cannot appear nested inside another 'var' or "
+      "'let' pattern", (unsigned))
+ERROR(var_pattern_in_var_inout,none,
       "'%select{let|inout|var}0' cannot appear nested inside another 'var', "
       "'let', or 'inout' pattern", (unsigned))
 ERROR(extra_var_in_multiple_pattern_list,none,
@@ -2077,5 +2080,11 @@ ERROR(parser_new_parser_errors,none,
       "new Swift parser generated errors for code that C++ parser accepted",
        ())
 
+// MARK: Reference Binding Diagnostics
+ERROR(sil_markuncheckedreferencebinding_requires_attribute,none,
+      "mark_unchecked_reference_binding requires an attribute like [inout]", ())
+ERROR(sil_markuncheckedreferencebinding_invalid_attribute,none,
+      "Attribute '[%0]' can not be applied to mark_unchecked_reference_binding", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSIL.def

@@ -816,5 +816,16 @@ WARNING(nontrivial_string_to_rawpointer_conversion,none,
         "forming %0 to an inout variable of type String exposes the internal representation "
         "rather than the string contents.", (Type))
 
+// MARK: Reference Binding Warnings
+ERROR(sil_referencebinding_unknown_pattern, none,
+      "reference binding that the compiler does not understand how to check. Please file a bug",
+      ())
+ERROR(sil_referencebinding_src_used_within_inout_scope, none,
+      "var bound to inout binding cannot be used within the inout binding's scope",
+      ())
+NOTE(sil_referencebinding_inout_binding_here, none,
+      "inout binding here",
+      ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Basic/Features.def

@@ -179,6 +179,9 @@ EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
 /// Generate bindings for functions that 'throw' in the C++ section of the generated Clang header.
 EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false)
 
+/// Enable reference bindings.
+EXPERIMENTAL_FEATURE(ReferenceBindings, false)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

include/swift/Parse/Parser.h

@@ -2057,7 +2057,7 @@ DeclNameRef formDeclNameRef(ASTContext &ctx,
                             bool isCxxClassTemplateSpec = false);
 
 /// Whether a given token can be the start of a decl.
-bool isKeywordPossibleDeclStart(const Token &Tok);
+bool isKeywordPossibleDeclStart(const LangOptions &options, const Token &Tok);
 
 } // end namespace swift
 

include/swift/SIL/MemAccessUtils.h

@@ -1632,6 +1632,7 @@ inline bool isAccessStorageIdentityCast(SingleValueInstruction *svi) {
   // Simply pass-thru the incoming address.
   case SILInstructionKind::MarkUninitializedInst:
   case SILInstructionKind::MarkMustCheckInst:
+  case SILInstructionKind::MarkUnresolvedReferenceBindingInst:
   case SILInstructionKind::MarkDependenceInst:
   case SILInstructionKind::CopyValueInst:
     return true;

include/swift/SIL/SILBuilder.h

@@ -1330,6 +1330,13 @@ class SILBuilder {
                       MarkMustCheckInst(getSILDebugLocation(loc), src, kind));
   }
 
+  MarkUnresolvedReferenceBindingInst *createMarkUnresolvedReferenceBindingInst(
+      SILLocation loc, SILValue src,
+      MarkUnresolvedReferenceBindingInst::Kind kind) {
+    return insert(new (getModule()) MarkUnresolvedReferenceBindingInst(
+        getSILDebugLocation(loc), src, kind));
+  }
+
   CopyableToMoveOnlyWrapperValueInst *
   createOwnedCopyableToMoveOnlyWrapperValue(SILLocation loc, SILValue src) {
     return insert(new (getModule()) CopyableToMoveOnlyWrapperValueInst(

include/swift/SIL/SILCloner.h

@@ -1889,6 +1889,16 @@ void SILCloner<ImplClass>::visitMarkMustCheckInst(MarkMustCheckInst *Inst) {
   recordClonedInstruction(Inst, MVI);
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitMarkUnresolvedReferenceBindingInst(
+    MarkUnresolvedReferenceBindingInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  auto *MVI = getBuilder().createMarkUnresolvedReferenceBindingInst(
+      getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand()),
+      Inst->getKind());
+  recordClonedInstruction(Inst, MVI);
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitMoveOnlyWrapperToCopyableValueInst(
     MoveOnlyWrapperToCopyableValueInst *inst) {

include/swift/SIL/SILInstruction.h

@@ -8339,6 +8339,37 @@ class MarkMustCheckInst
   }
 };
 
+/// A marker instruction that states a given alloc_box or alloc_stack is a
+/// reference binding that must be transformed.
+class MarkUnresolvedReferenceBindingInst
+    : public UnaryInstructionBase<
+          SILInstructionKind::MarkUnresolvedReferenceBindingInst,
+          SingleValueInstruction>,
+      public OwnershipForwardingMixin {
+  friend class SILBuilder;
+
+public:
+  enum class Kind : unsigned {
+    Invalid = 0,
+
+    InOut = 1,
+  };
+
+private:
+  Kind kind;
+
+  MarkUnresolvedReferenceBindingInst(SILDebugLocation debugLoc,
+                                     SILValue operand, Kind kind)
+      : UnaryInstructionBase(debugLoc, operand, operand->getType()),
+        OwnershipForwardingMixin(
+            SILInstructionKind::MarkUnresolvedReferenceBindingInst,
+            operand->getOwnershipKind()),
+        kind(kind) {}
+
+public:
+  Kind getKind() const { return kind; }
+};
+
 /// Convert from a non-trivial copyable type to an `@moveOnly` wrapper type.
 ///
 /// IMPORTANT: Unlike other forwarding instructions, the ownership of
@@ -10693,7 +10724,8 @@ inline bool OwnershipForwardingMixin::isa(SILInstructionKind kind) {
          OwnershipForwardingConversionInst::classof(kind) ||
          OwnershipForwardingSelectEnumInstBase::classof(kind) ||
          OwnershipForwardingMultipleValueInstruction::classof(kind) ||
-         kind == SILInstructionKind::MarkMustCheckInst;
+         kind == SILInstructionKind::MarkMustCheckInst ||
+         kind == SILInstructionKind::MarkUnresolvedReferenceBindingInst;
 }
 
 inline OwnershipForwardingMixin *
@@ -10717,6 +10749,8 @@ OwnershipForwardingMixin::get(SILInstruction *inst) {
     return result;
   if (auto *result = dyn_cast<MarkMustCheckInst>(inst))
     return result;
+  if (auto *result = dyn_cast<MarkUnresolvedReferenceBindingInst>(inst))
+    return result;
   if (auto *result = dyn_cast<MoveOnlyWrapperToCopyableValueInst>(inst))
     return result;
   if (auto *result = dyn_cast<CopyableToMoveOnlyWrapperValueInst>(inst))

include/swift/SIL/SILNodes.def

@@ -467,6 +467,12 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   // running the relevant diagnostic.
   SINGLE_VALUE_INST(MarkMustCheckInst, mark_must_check,
                     SingleValueInstruction, None, DoesNotRelease)
+  // A canary value inserted by a SIL generating frontend to signal to the
+  // reference binding transform to check/transform a specific value.  Valid
+  // only in Raw SIL. The relevant checkers should remove the instruction after
+  // successfully running the relevant diagnostic.
+  SINGLE_VALUE_INST(MarkUnresolvedReferenceBindingInst, mark_unresolved_reference_binding,
+                    SingleValueInstruction, None, DoesNotRelease)
   // Convert a $T to $@moveOnly T. This is the method that one uses to convert a
   // trivial value to a non-trivial move only value. Ownership is fixed at construction by
   // frontend to express specific semantics: guaranteed for guaranteed function arguments

include/swift/SILOptimizer/PassManager/Passes.def

@@ -468,6 +468,8 @@ PASS(MoveOnlyBorrowToDestructureTransform,
      "used to convert borrow+projection to destructures. Once this has run, the move "
      "only object checker runs and ensures that the destructures do not create "
      "any move only errors with respect to non-borrow+projection uses")
+PASS(ReferenceBindingTransform, "sil-reference-binding-transform",
+     "Check/transform reference bindings")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)