Merge pull request #1393 from swiftwasm/master

[pull] swiftwasm from master

Author: pull[bot]

cmake/modules/DarwinSDKs.cmake

@@ -16,23 +16,6 @@ set(SUPPORTED_WATCHOS_ARCHS "armv7k")
 set(SUPPORTED_WATCHOS_SIMULATOR_ARCHS "i386;arm64")
 set(SUPPORTED_OSX_ARCHS "x86_64;arm64;arm64e")
 
-# Get the SDK version from SDKSettings.
-execute_process(
-  COMMAND "defaults" "read" "${CMAKE_OSX_SYSROOT}/SDKSettings.plist" "Version"
-    OUTPUT_VARIABLE SWIFT_OSX_SDK_VERSION
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-# Remove the last component, if any. e.g. 10.15.26 -> 10.15
-string(REGEX REPLACE "\([0-9]*[.][0-9]*\)[.][0-9]*" "\\1"
-       SWIFT_OSX_SDK_VERSION "${SWIFT_OSX_SDK_VERSION}")
-
-if (${SWIFT_OSX_SDK_VERSION} STREQUAL "10.14" OR
-    ${SWIFT_OSX_SDK_VERSION} STREQUAL "10.15")
-  set(SUPPORTED_OSX_ARCHS "x86_64")
-else()
-  set(SUPPORTED_OSX_ARCHS "x86_64;arm64e")
-endif()
-
 is_sdk_requested(OSX swift_build_osx)
 if(swift_build_osx)
   configure_sdk_darwin(

include/swift/AST/DiagnosticsSema.def

@@ -3095,10 +3095,16 @@ ERROR(derivative_attr_class_member_dynamic_self_result_unsupported,none,
 ERROR(derivative_attr_nonfinal_class_init_unsupported,none,
       "cannot register derivative for 'init' in a non-final class; consider "
       "making %0 final", (Type))
+ERROR(derivative_attr_unsupported_accessor_kind,none,
+      "cannot register derivative for %0", (/*accessorKind*/ DescriptiveDeclKind))
 // TODO(SR-13096): Remove this temporary diagnostic.
 ERROR(derivative_attr_class_setter_unsupported,none,
       "cannot yet register derivative for class property or subscript setters",
       ())
+// TODO(TF-982): Remove this temporary diagnostic.
+NOTE(derivative_attr_protocol_requirement_unsupported,none,
+     "cannot yet register derivative default implementation for protocol "
+     "requirements", ())
 ERROR(derivative_attr_original_already_has_derivative,none,
       "a derivative already exists for %0", (DeclName))
 NOTE(derivative_attr_duplicate_note,none,
@@ -3134,15 +3140,25 @@ NOTE(transpose_attr_wrt_self_self_type_mismatch_note,none,
      "%1", (Type, Type))
 
 // Automatic differentiation attributes
-ERROR(autodiff_attr_original_decl_invalid_kind,none,
-      "%0 is not a 'func', 'init', 'subscript', or 'var' computed property "
-      "declaration", (DeclNameRef))
-ERROR(autodiff_attr_accessor_not_found,none,
-      "%0 does not have a '%1' accessor", (DeclNameRef, StringRef))
-ERROR(autodiff_attr_original_decl_none_valid_found,none,
-      "could not find function %0 with expected type %1", (DeclNameRef, Type))
-ERROR(autodiff_attr_original_decl_not_same_type_context,none,
-      "%0 is not defined in the current type context", (DeclNameRef))
+ERROR(autodiff_attr_original_decl_ambiguous,none,
+      "referenced declaration %0 is ambiguous", (DeclNameRef))
+NOTE(autodiff_attr_original_decl_ambiguous_candidate,none,
+     "candidate %0 found here", (DescriptiveDeclKind))
+ERROR(autodiff_attr_original_decl_none_valid,none,
+      "referenced declaration %0 could not be resolved", (DeclNameRef))
+NOTE(autodiff_attr_original_decl_invalid_kind,none,
+     "candidate %0 is not a 'func', 'init', 'subscript', or 'var' computed "
+     "property declaration", (DescriptiveDeclKind))
+NOTE(autodiff_attr_original_decl_missing_accessor,none,
+     "candidate %0 does not have a %1",
+     (DescriptiveDeclKind, /*accessorDeclKind*/ DescriptiveDeclKind))
+NOTE(autodiff_attr_original_decl_type_mismatch,none,
+     "candidate %0 does not have "
+     "%select{expected type|type equal to or less constrained than}2 %1",
+     (DescriptiveDeclKind, Type, /*hasGenericSignature*/ bool))
+NOTE(autodiff_attr_original_decl_not_same_type_context,none,
+     "candidate %0 is not defined in the current type context",
+     (DescriptiveDeclKind))
 ERROR(autodiff_attr_original_void_result,none,
       "cannot differentiate void function %0", (DeclName))
 ERROR(autodiff_attr_original_multiple_semantic_results,none,

lib/Demangling/Punycode.cpp

@@ -12,6 +12,7 @@
 
 #include "swift/Demangling/Punycode.h"
 #include "swift/Demangling/ManglingUtils.h"
+#include <limits>
 #include <vector>
 #include <cstdint>
 
@@ -49,7 +50,7 @@ static int digit_index(char value) {
 static bool isValidUnicodeScalar(uint32_t S) {
   // Also accept the range of 0xD800 - 0xD880, which is used for non-symbol
   // ASCII characters.
-  return (S < 0xD880) || (S >= 0xE000 && S <= 0x1FFFFF);
+  return (S < 0xD880) || (S >= 0xE000 && S <= 0x10FFFF);
 }
 
 // Section 6.1: Bias adaptation function
@@ -88,7 +89,7 @@ bool Punycode::decodePunycode(StringRef InputPunycode,
     for (char c : InputPunycode.slice(0, lastDelimiter)) {
       // fail on any non-basic code point
       if (static_cast<unsigned char>(c) > 0x7f)
-        return true;
+        return false;
       OutCodePoints.push_back(c);
     }
     // if more than zero code points were consumed then consume one more
@@ -103,28 +104,37 @@ bool Punycode::decodePunycode(StringRef InputPunycode,
     for (int k = base; ; k += base) {
       // consume a code point, or fail if there was none to consume
       if (InputPunycode.empty())
-        return true;
+        return false;
       char codePoint = InputPunycode.front();
       InputPunycode = InputPunycode.slice(1, InputPunycode.size());
       // let digit = the code point's digit-value, fail if it has none
       int digit = digit_index(codePoint);
       if (digit < 0)
-        return true;
+        return false;
 
+      // Fail if i + (digit * w) would overflow
+      if (digit > (std::numeric_limits<int>::max() - i) / w)
+        return false;
       i = i + digit * w;
       int t = k <= bias ? tmin
             : k >= bias + tmax ? tmax
             : k - bias;
       if (digit < t)
         break;
+      // Fail if w * (base - t) would overflow
+      if (w > std::numeric_limits<int>::max() / (base - t))
+        return false;
       w = w * (base - t);
     }
     bias = adapt(i - oldi, OutCodePoints.size() + 1, oldi == 0);
+    // Fail if n + i / (OutCodePoints.size() + 1) would overflow
+    if (i / (OutCodePoints.size() + 1) > std::numeric_limits<int>::max() - n)
+      return false;
     n = n + i / (OutCodePoints.size() + 1);
     i = i % (OutCodePoints.size() + 1);
     // if n is a basic code point then fail
     if (n < 0x80)
-      return true;
+      return false;
     // insert n into output at position i
     OutCodePoints.insert(OutCodePoints.begin() + i, n);
     ++i;
@@ -168,11 +178,17 @@ bool Punycode::encodePunycode(const std::vector<uint32_t> &InputCodePoints,
       if (codePoint >= n && codePoint < m)
         m = codePoint;
     }
-    
+
+    if ((m - n) > (std::numeric_limits<int>::max() - delta) / (h + 1))
+      return false;
     delta = delta + (m - n) * (h + 1);
     n = m;
     for (auto c : InputCodePoints) {
-      if (c < n) ++delta;
+      if (c < n) {
+        if (delta == std::numeric_limits<int>::max())
+          return false;
+        ++delta;
+      }
       if (c == n) {
         int q = delta;
         for (int k = base; ; k += base) {
@@ -285,11 +301,12 @@ static bool convertUTF8toUTF32(llvm::StringRef InputUTF8,
   auto end = InputUTF8.end();
   while (ptr < end) {
     uint8_t first = *ptr++;
+    uint32_t code_point = 0;
     if (first < 0x80) {
       if (Mangle::isValidSymbolChar(first) || !mapNonSymbolChars) {
-        OutUTF32.push_back(first);
+        code_point = first;
       } else {
-        OutUTF32.push_back((uint32_t)first + 0xD800);
+        code_point = (uint32_t)first + 0xD800;
       }
     } else if (first < 0xC0) {
       // Invalid continuation byte.
@@ -301,7 +318,7 @@ static bool convertUTF8toUTF32(llvm::StringRef InputUTF8,
       uint8_t second = *ptr++;
       if (!isContinuationByte(second))
         return false;
-      OutUTF32.push_back(((first & 0x1F) << 6) | (second & 0x3F));
+      code_point = ((first & 0x1F) << 6) | (second & 0x3F);
     } else if (first < 0xF0) {
       // Three-byte sequence.
       if (end - ptr < 2)
@@ -310,8 +327,9 @@ static bool convertUTF8toUTF32(llvm::StringRef InputUTF8,
       uint8_t third = *ptr++;
       if (!isContinuationByte(second) || !isContinuationByte(third))
         return false;
-      OutUTF32.push_back(((first & 0xF) << 12) | ((second & 0x3F) << 6)
-                         | ( third  & 0x3F      ));
+      code_point = ((first & 0xF) << 12)
+                 | ((second & 0x3F) << 6)
+                 | ( third  & 0x3F      );
     } else if (first < 0xF8) {
       // Four-byte sequence.
       if (end - ptr < 3)
@@ -322,13 +340,17 @@ static bool convertUTF8toUTF32(llvm::StringRef InputUTF8,
       if (!isContinuationByte(second) || !isContinuationByte(third)
           || !isContinuationByte(fourth))
         return false;
-      OutUTF32.push_back(((first & 0x7) << 18) | ((second & 0x3F) << 12)
-                         | ((third  & 0x3F) <<  6)
-                         | ( fourth & 0x3F       ));
+      code_point = ((first & 0x7) << 18)
+                  | ((second & 0x3F) << 12)
+                  | ((third  & 0x3F) <<  6)
+                  | ( fourth & 0x3F       );
     } else {
       // Unused sequence length.
       return false;
     }
+    if (!isValidUnicodeScalar(code_point))
+      return false;
+    OutUTF32.push_back(code_point);
   }
   return true;
 }

lib/Sema/CSBindings.cpp

@@ -1034,7 +1034,8 @@ bool TypeVarBindingProducer::computeNext() {
 
     auto srcLocator = binding.getLocator();
     if (srcLocator &&
-        srcLocator->isLastElement<LocatorPathElt::ApplyArgToParam>() &&
+        (srcLocator->isLastElement<LocatorPathElt::ApplyArgToParam>() ||
+         srcLocator->isLastElement<LocatorPathElt::AutoclosureResult>()) &&
         !type->hasTypeVariable() && type->isKnownStdlibCollectionType()) {
       // If the type binding comes from the argument conversion, let's
       // instead of binding collection types directly, try to bind