Merge branch 'main' into castmessage-whentypenotfound

Author: dancamarotto

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -329,7 +329,7 @@ private struct CollectedEffects {
 
   /// Adds effects to a specific value.
   ///
-  /// If the value comes from an argument (or mutliple arguments), then the effects are added
+  /// If the value comes from an argument (or multiple arguments), then the effects are added
   /// to the corrseponding `argumentEffects`. Otherwise they are added to the `global` effects.
   private mutating func addEffects(_ effects: SideEffects.GlobalEffects, to value: Value) {
     addEffects(effects, to: value, fromInitialPath: defaultPath(for: value))

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -107,7 +107,14 @@ private func tryDevirtualizeRelease(
   // argument.
   let functionRef = builder.createFunctionRef(dealloc)
 
-  let substitutionMap = context.getContextSubstitutionMap(for: type)
+  let substitutionMap: SubstitutionMap
+  if dealloc.isGenericFunction {
+    substitutionMap = context.getContextSubstitutionMap(for: type)
+  } else {
+    // In embedded Swift, dealloc might be a specialized deinit, so the substitution map on the old apply isn't valid for the new apply
+    substitutionMap = SubstitutionMap()
+  }
+
   builder.createApply(function: functionRef, substitutionMap, arguments: [beginDealloc])
   context.erase(instruction: lastRelease)
 }

SwiftCompilerSources/Sources/SIL/Test.swift

@@ -34,7 +34,7 @@
 //
 // CASE STUDY:
 // Here's an example of how it works:
-// 0) A source file, NeatUtils.cpp contains
+// 0) A source file, NeatUtils.swift contains
 //
 //    fileprivate func myNeatoUtility(int: Int, value: Value, function: Function) { ... }
 //

include/swift/AST/DiagnosticsSema.def

@@ -104,6 +104,12 @@ ERROR(could_not_find_enum_case,none,
       "enum type %0 has no case %1; did you mean %2?",
       (Type, DeclNameRef, DeclName))
 
+ERROR(could_not_find_imported_enum_case,none,
+      "type %0 has no case %1, but it does have a case named %2; if %1 worked "
+      "before, a recent change to the underlying C enum may have affected how "
+      "prefixes are stripped from its case names",
+      (Type, DeclNameRef, ValueDecl *))
+
 NOTE(did_you_mean_raw_type,none,
      "did you mean to specify a raw type on the enum declaration?", ())
 
@@ -1730,6 +1736,9 @@ NOTE(fixit_add_private_for_objc_implementation,none,
 NOTE(fixit_add_final_for_objc_implementation,none,
      "add 'final' to define a Swift %0 that cannot be overridden",
      (DescriptiveDeclKind))
+NOTE(fixit_add_nonobjc_for_objc_implementation,none,
+     "add '@nonobjc' to define a Swift-only %0",
+     (DescriptiveDeclKind))
 
 ERROR(objc_implementation_wrong_category,none,
       "%kind0 should be implemented in extension for "

include/swift/Basic/StringExtras.h

@@ -223,6 +223,8 @@ namespace swift {
 
       reverse_iterator rbegin() const { return reverse_iterator(end()); }
       reverse_iterator rend() const { return reverse_iterator(begin()); }
+
+      bool hasWordStartingAt(unsigned targetPosition) const;
     };
 
     /// Retrieve the camelCase words in the given string.
@@ -236,6 +238,10 @@ namespace swift {
     /// case of the first letter.
     bool startsWithIgnoreFirstCase(StringRef word1, StringRef word2);
 
+    /// Check whether the first word ends with the second word, ignoring the
+    /// case of the first word (handles initialisms).
+    bool hasWordSuffix(StringRef haystack, StringRef needle);
+
     /// Lowercase the first word within the given camelCase string.
     ///
     /// \param string The string to lowercase.

include/swift/IDE/CompletionLookup.h

@@ -105,6 +105,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     TypeInDeclContext,
     ImportFromModule,
     GenericRequirement,
+
+    /// Look up stored properties within a type.
+    StoredProperty,
   };
 
   LookupKind Kind;
@@ -528,6 +531,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void getValueExprCompletions(Type ExprType, ValueDecl *VD = nullptr,
                                bool IsDeclUnapplied = false);
 
+  /// Add completions for stored properties of \p D.
+  void getStoredPropertyCompletions(const NominalTypeDecl *D);
+
   void collectOperators(SmallVectorImpl<OperatorDecl *> &results);
 
   void addPostfixBang(Type resultType);

include/swift/Parse/IDEInspectionCallbacks.h

@@ -36,6 +36,25 @@ enum class CustomSyntaxAttributeKind {
   Available,
   FreestandingMacro,
   AttachedMacro,
+  StorageRestrictions
+};
+
+/// A bit of a hack. When completing inside the '@storageRestrictions'
+/// attribute, we use the \c ParamIndex field to communicate where inside the
+/// attribute we are performing the completion.
+enum class StorageRestrictionsCompletionKind : int {
+  /// We are completing directly after the '(' and require a 'initializes' or
+  /// 'accesses' label.
+  Label,
+  /// We are completing in a context that only allows arguments (ie. accessed or
+  /// initialized variables) and doesn't permit an argument label.
+  Argument,
+  /// Completion in a context that allows either an argument or the
+  /// 'initializes' label.
+  ArgumentOrInitializesLabel,
+  /// Completion in a context that allows either an argument or the
+  /// 'accesses' label.
+  ArgumentOrAccessesLabel
 };
 
 /// Parser's interface to code completion.

include/swift/SIL/SILFunctionConventions.h

@@ -214,6 +214,11 @@ class SILFunctionConventions {
     return getSILType(funcTy->getErrorResult(), context);
   }
 
+  bool isTypedError() const {
+    return !funcTy->getErrorResult()
+        .getInterfaceType()->isExistentialWithError();
+  }
+
   /// Returns an array of result info.
   /// Provides convenient access to the underlying SILFunctionType.
   ArrayRef<SILResultInfo> getResults() const {

include/swift/Sema/SyntacticElementTarget.h

@@ -147,7 +147,7 @@ class SyntacticElementTarget {
       ForEachStmt *stmt;
       DeclContext *dc;
       Pattern *pattern;
-      bool bindPatternVarsOneWay;
+      bool ignoreWhereClause;
       ForEachStmtInfo info;
     } forEachStmt;
 
@@ -227,11 +227,11 @@ class SyntacticElementTarget {
   }
 
   SyntacticElementTarget(ForEachStmt *stmt, DeclContext *dc,
-                         bool bindPatternVarsOneWay)
+                         bool ignoreWhereClause)
       : kind(Kind::forEachStmt) {
     forEachStmt.stmt = stmt;
     forEachStmt.dc = dc;
-    forEachStmt.bindPatternVarsOneWay = bindPatternVarsOneWay;
+    forEachStmt.ignoreWhereClause = ignoreWhereClause;
   }
 
   /// Form a target for the initialization of a pattern from an expression.
@@ -249,7 +249,7 @@ class SyntacticElementTarget {
   /// Form a target for a for-in loop.
   static SyntacticElementTarget forForEachStmt(ForEachStmt *stmt,
                                                DeclContext *dc,
-                                               bool bindPatternVarsOneWay);
+                                               bool ignoreWhereClause = false);
 
   /// Form a target for a property with an attached property wrapper that is
   /// initialized out-of-line.
@@ -469,10 +469,6 @@ class SyntacticElementTarget {
   bool shouldBindPatternVarsOneWay() const {
     if (kind == Kind::expression)
       return expression.bindPatternVarsOneWay;
-
-    if (kind == Kind::forEachStmt)
-      return forEachStmt.bindPatternVarsOneWay;
-
     return false;
   }
 
@@ -521,6 +517,11 @@ class SyntacticElementTarget {
     return expression.initialization.patternBindingIndex;
   }
 
+  bool ignoreForEachWhereClause() const {
+    assert(isForEachStmt());
+    return forEachStmt.ignoreWhereClause;
+  }
+
   const ForEachStmtInfo &getForEachStmtInfo() const {
     assert(isForEachStmt());
     return forEachStmt.info;

lib/Basic/StringExtras.cpp

@@ -215,6 +215,17 @@ void WordIterator::computePrevPosition() const {
   PrevPositionValid = true;
 }
 
+bool camel_case::Words::hasWordStartingAt(unsigned targetPosition) const {
+  // Iterate over the words until we see one at or past targetPosition.
+  // FIXME: Is there a faster way to do this by looking at the characters around
+  //        the position?
+  for (auto i = begin(); i != end() && i.getPosition() <= targetPosition; i++) {
+    if (i.getPosition() == targetPosition)
+      return true;
+  }
+  return false;
+}
+
 StringRef camel_case::getFirstWord(StringRef string) {
   if (string.empty())
     return "";
@@ -249,6 +260,30 @@ bool camel_case::startsWithIgnoreFirstCase(StringRef word1, StringRef word2) {
   return word1.substr(1, word2.size() - 1) == word2.substr(1);
 }
 
+bool camel_case::hasWordSuffix(StringRef haystack, StringRef needle) {
+  // Is it even possible for one to be a suffix of the other?
+  if (needle.empty() || haystack.size() <= needle.size())
+    return false;
+
+  // Does haystack have a word boundary at the right position?
+  auto targetPosition = haystack.size() - needle.size();
+  if (!Words(haystack).hasWordStartingAt(targetPosition))
+    return false;
+
+  StringRef suffix = haystack.substr(targetPosition);
+
+  // Fast path: Without potentially copying the strings, do they match?
+  if (sameWordIgnoreFirstCase(suffix, needle))
+    return true;
+
+  // Flatten out leading initialisms. Do they match?
+  SmallString<32> suffixScratch, needleScratch;
+  auto suffixFlat = toLowercaseInitialisms(suffix, suffixScratch);
+  auto needleFlat = toLowercaseInitialisms(needle, needleScratch);
+
+  return suffixFlat == needleFlat;
+}
+
 StringRef camel_case::toLowercaseWord(StringRef string,
                                       SmallVectorImpl<char> &scratch) {
   if (string.empty())