Merge pull request #50 from kateinoigakukun/merge/44a64755666ed1272e0b0e949ac676ac92667bcd

Merge 44a6475

Author: kateinoigakukun

cmake/modules/AddSwift.cmake

@@ -28,16 +28,6 @@ function(add_dependencies_multiple_targets)
   endif()
 endfunction()
 
-# Compute the library subdirectory to use for the given sdk and
-# architecture, placing the result in 'result_var_name'.
-function(compute_library_subdir result_var_name sdk arch)
-  if(sdk IN_LIST SWIFT_APPLE_PLATFORMS OR sdk STREQUAL "MACCATALYST")
-    set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}" PARENT_SCOPE)
-  else()
-    set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}" PARENT_SCOPE)
-  endif()
-endfunction()
-
 function(_compute_lto_flag option out_var)
   string(TOLOWER "${option}" lowercase_option)
   if (lowercase_option STREQUAL "full")
@@ -163,9 +153,12 @@ function(_add_variant_c_compile_link_flags)
   endif()
 
   if(IS_DARWIN)
+    # We collate -F with the framework path to avoid unwanted deduplication
+    # of options by target_compile_options -- this way no undesired
+    # side effects are introduced should a new search path be added.
     list(APPEND result
       "-arch" "${CFLAGS_ARCH}"
-      "-F" "${SWIFT_SDK_${CFLAGS_SDK}_PATH}/../../../Developer/Library/Frameworks")
+      "-F${SWIFT_SDK_${CFLAGS_SDK}_PATH}/../../../Developer/Library/Frameworks")
 
     set(add_explicit_version TRUE)
 
@@ -409,8 +402,11 @@ function(_add_variant_swift_compile_flags
   endif()
 
   if(IS_DARWIN)
+    # We collate -F with the framework path to avoid unwanted deduplication
+    # of options by target_compile_options -- this way no undesired
+    # side effects are introduced should a new search path be added.
     list(APPEND result
-      "-F" "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}/../../../Developer/Library/Frameworks")
+      "-F${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}/../../../Developer/Library/Frameworks")
   endif()
 
   is_build_type_optimized("${build_type}" optimized)

cmake/modules/SwiftSource.cmake

@@ -1,6 +1,16 @@
 include(macCatalystUtils)
 include(SwiftUtils)
 
+# Compute the library subdirectory to use for the given sdk and
+# architecture, placing the result in 'result_var_name'.
+function(compute_library_subdir result_var_name sdk arch)
+  if(sdk IN_LIST SWIFT_APPLE_PLATFORMS OR sdk STREQUAL "MACCATALYST")
+    set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}" PARENT_SCOPE)
+  else()
+    set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}" PARENT_SCOPE)
+  endif()
+endfunction()
+
 # Process the sources within the given variable, pulling out any Swift
 # sources to be compiled with 'swift' directly. This updates
 # ${sourcesvar} in place with the resulting list and ${externalvar} with the

include/swift/AST/SemanticAttrs.def

@@ -34,6 +34,8 @@ SEMANTICS_ATTR(STRING_PLUS_EQUALS, "string.plusequals")
 SEMANTICS_ATTR(FIND_STRING_SWITCH_CASE, "findStringSwitchCase")
 SEMANTICS_ATTR(FIND_STRING_SWITCH_CASE_WITH_CACHE, "findStringSwitchCaseWithCache")
 
+SEMANTICS_ATTR(BINARY_INTEGER_DESCRIPTION, "binaryInteger.description")
+
 SEMANTICS_ATTR(SWIFT_CONCURRENT_ASYNC, "swift.concurrent.async")
 SEMANTICS_ATTR(SWIFT_CONCURRENT_SAFE, "swift.concurrent.safe")
 SEMANTICS_ATTR(SWIFT_CONCURRENT, "swift.concurrent")

include/swift/Runtime/MutexWASI.h

@@ -1,17 +1,20 @@
-//===--- MutexWin32.h - -----------------------------------------*- C++ -*-===//
+//===--- MutexWASI.h - -----------------------------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 //
-// Mutex, ConditionVariable, Read/Write lock, and Scoped lock implementations
-// using Windows Slim Reader/Writer Locks and Conditional Variables.
+// No-op implementation of locks for the WebAssembly System Interface. The 
+// implementation does not need to perform locking, because as of January 2020 
+// WebAssembly does not support threads.
+// See the current status at https://github.com/WebAssembly/proposals and 
+// https://github.com/webassembly/threads
 //
 //===----------------------------------------------------------------------===//
 

lib/AST/Attr.cpp

@@ -1360,10 +1360,19 @@ OriginallyDefinedInAttr::isActivePlatform(const ASTContext &ctx) const {
   Result.Platform = Platform;
   Result.Version = MovedVersion;
   Result.ModuleName = OriginalModuleName;
-  if (isPlatformActive(Platform, ctx.LangOpts)) {
+  if (isPlatformActive(Platform, ctx.LangOpts, /*TargetVariant*/false)) {
     Result.IsSimulator = ctx.LangOpts.Target.isSimulatorEnvironment();
     return Result;
   }
+
+  // Also check if the platform is active by using target variant. This ensures
+  // we emit linker directives for multiple platforms when building zippered
+  // libraries.
+  if (ctx.LangOpts.TargetVariant.hasValue() &&
+      isPlatformActive(Platform, ctx.LangOpts, /*TargetVariant*/true)) {
+    Result.IsSimulator = ctx.LangOpts.TargetVariant->isSimulatorEnvironment();
+    return Result;
+  }
   return None;
 }
 

lib/AST/GenericSignatureBuilder.cpp

@@ -4361,6 +4361,8 @@ ConstraintResult GenericSignatureBuilder::addTypeRequirement(
 
       if (subjectType->is<DependentMemberType>()) {
         subjectType = resolveDependentMemberTypes(*this, subjectType);
+      } else {
+        subjectType = ErrorType::get(subjectType);
       }
 
       auto invalidConstraint = Constraint<Type>(

lib/IRGen/IRGenDebugInfo.cpp

@@ -1847,7 +1847,7 @@ void IRGenDebugInfoImpl::setCurrentLoc(IRBuilder &Builder,
   auto DL = llvm::DebugLoc::get(L.Line, L.Column, Scope, InlinedAt);
   Builder.SetCurrentDebugLocation(DL);
 }
-  
+
 void IRGenDebugInfoImpl::addFailureMessageToCurrentLoc(IRBuilder &Builder,
                                                        StringRef failureMsg) {
   auto TrapLoc = Builder.getCurrentDebugLocation();
@@ -1864,7 +1864,7 @@ void IRGenDebugInfoImpl::addFailureMessageToCurrentLoc(IRBuilder &Builder,
   FuncName += failureMsg;
 
   llvm::DISubprogram *TrapSP = DBuilder.createFunction(
-     MainModule, StringRef(), FuncName, TrapLoc->getFile(), 0, DIFnTy, 0,
+     MainModule, FuncName, StringRef(), TrapLoc->getFile(), 0, DIFnTy, 0,
      llvm::DINode::FlagArtificial, llvm::DISubprogram::SPFlagDefinition,
      nullptr, nullptr, nullptr);
 

lib/SILGen/SILGenEpilog.cpp

@@ -30,8 +30,8 @@ void SILGenFunction::prepareEpilog(Type resultType, bool isThrowing,
     // emits unreachable if there is no source level return.
     NeedsReturn = (fnConv.funcTy->getNumResults() != 0);
     for (auto directResult : fnConv.getDirectSILResults()) {
-      SILType resultType =
-          F.mapTypeIntoContext(fnConv.getSILType(directResult));
+      SILType resultType = F.getLoweredType(
+          F.mapTypeIntoContext(fnConv.getSILType(directResult)));
       epilogBB->createPhiArgument(resultType, ValueOwnershipKind::Owned);
     }
   }

lib/SILOptimizer/Utils/ConstExpr.cpp

@@ -56,6 +56,8 @@ enum class WellKnownFunction {
   StringEquals,
   // String.percentEscapedString.getter
   StringEscapePercent,
+  // BinaryInteger.description.getter
+  BinaryIntegerDescription,
   // _assertionFailure(_: StaticString, _: StaticString, file: StaticString,...)
   AssertionFailure,
   // A function taking one argument that prints the symbolic value of the
@@ -83,6 +85,8 @@ static llvm::Optional<WellKnownFunction> classifyFunction(SILFunction *fn) {
     return WellKnownFunction::StringEquals;
   if (fn->hasSemanticsAttr(semantics::STRING_ESCAPE_PERCENT_GET))
     return WellKnownFunction::StringEscapePercent;
+  if (fn->hasSemanticsAttr(semantics::BINARY_INTEGER_DESCRIPTION))
+    return WellKnownFunction::BinaryIntegerDescription;
   if (fn->hasSemanticsAttrThatStartsWith("programtermination_point"))
     return WellKnownFunction::AssertionFailure;
   // A call to a function with the following semantics annotation will be
@@ -780,6 +784,13 @@ extractStaticStringValue(SymbolicValue staticString) {
   return staticStringProps[0].getStringValue();
 }
 
+static Optional<StringRef>
+extractStringOrStaticStringValue(SymbolicValue stringValue) {
+  if (stringValue.getKind() == SymbolicValue::String)
+    return stringValue.getStringValue();
+  return extractStaticStringValue(stringValue);
+}
+
 /// If the specified type is a Swift.Array of some element type, then return the
 /// element type.  Otherwise, return a null Type.
 static Type getArrayElementType(Type ty) {
@@ -789,6 +800,28 @@ static Type getArrayElementType(Type ty) {
   return Type();
 }
 
+/// Check if the given type \p ty is a stdlib integer type and if so return
+/// whether the type is signed. Returns \c None if \p ty is not a stdlib integer
+/// type, \c true if it is a signed integer type and \c false if it is an
+/// unsigned integer type.
+static Optional<bool> getSignIfStdlibIntegerType(Type ty) {
+  StructDecl *decl = ty->getStructOrBoundGenericStruct();
+  if (!decl)
+    return None;
+  ASTContext &astCtx = ty->getASTContext();
+  if (decl == astCtx.getIntDecl() || decl == astCtx.getInt8Decl() ||
+      decl == astCtx.getInt16Decl() || decl == astCtx.getInt32Decl() ||
+      decl == astCtx.getInt64Decl()) {
+    return true;
+  }
+  if (decl == astCtx.getUIntDecl() || decl == astCtx.getUInt8Decl() ||
+      decl == astCtx.getUInt16Decl() || decl == astCtx.getUInt32Decl() ||
+      decl == astCtx.getUInt64Decl()) {
+    return false;
+  }
+  return None;
+}
+
 /// Given a call to a well known function, collect its arguments as constants,
 /// fold it, and return None.  If any of the arguments are not constants, marks
 /// the call's results as Unknown, and return an Unknown with information about
@@ -803,8 +836,8 @@ ConstExprFunctionState::computeWellKnownCallResult(ApplyInst *apply,
     for (unsigned i = 0; i < apply->getNumArguments(); i++) {
       SILValue argument = apply->getArgument(i);
       SymbolicValue argValue = getConstantValue(argument);
-      Optional<StringRef> stringOpt = extractStaticStringValue(argValue);
-
+      Optional<StringRef> stringOpt =
+          extractStringOrStaticStringValue(argValue);
       // The first argument is a prefix that specifies the kind of failure
       // this is.
       if (i == 0) {
@@ -816,7 +849,6 @@ ConstExprFunctionState::computeWellKnownCallResult(ApplyInst *apply,
         }
         continue;
       }
-
       if (stringOpt) {
         message += ": ";
         message += stringOpt.getValue();
@@ -1064,6 +1096,42 @@ ConstExprFunctionState::computeWellKnownCallResult(ApplyInst *apply,
     setValue(apply, resultVal);
     return None;
   }
+  case WellKnownFunction::BinaryIntegerDescription: {
+    // BinaryInteger.description.getter
+    assert(conventions.getNumDirectSILResults() == 1 &&
+           conventions.getNumIndirectSILResults() == 0 &&
+           conventions.getNumParameters() == 1 && apply->hasSubstitutions() &&
+           "unexpected BinaryInteger.description.getter signature");
+    // Get the type of the argument and check if it is a signed or
+    // unsigned integer.
+    SILValue integerArgument = apply->getOperand(1);
+    CanType argumentType = substituteGenericParamsAndSimpify(
+        integerArgument->getType().getASTType());
+    Optional<bool> isSignedIntegerType =
+        getSignIfStdlibIntegerType(argumentType);
+    if (!isSignedIntegerType.hasValue()) {
+      return getUnknown(evaluator, (SILInstruction *)apply,
+                        UnknownReason::InvalidOperandValue);
+    }
+    // Load the stdlib integer's value and convert it to a string.
+    SymbolicValue stdlibIntegerValue =
+        getConstAddrAndLoadResult(integerArgument);
+    if (!stdlibIntegerValue.isConstant()) {
+      return stdlibIntegerValue;
+    }
+    SymbolicValue builtinIntegerValue =
+        stdlibIntegerValue.lookThroughSingleElementAggregates();
+    assert(builtinIntegerValue.getKind() == SymbolicValue::Integer &&
+           "stdlib integer type must store only a builtin integer");
+    APInt integer = builtinIntegerValue.getIntegerValue();
+    SmallString<8> integerString;
+    isSignedIntegerType.getValue() ? integer.toStringSigned(integerString)
+                                   : integer.toStringUnsigned(integerString);
+    SymbolicValue resultVal =
+        SymbolicValue::getString(integerString.str(), evaluator.getAllocator());
+    setValue(apply, resultVal);
+    return None;
+  }
   case WellKnownFunction::DebugPrint: {
     assert(apply->getNumArguments() == 1 &&
            "debug_print function must take exactly one argument");

lib/Sema/CSDiag.cpp

@@ -1296,21 +1296,6 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
     }
   }
 
-  // Let's check whether this is a situation when callee expects
-  // no arguments but N are given. Otherwise, just below
-  // `typeCheckArgumentChild*` is going to use `()` is a contextual type which
-  // is incorrect.
-  if (argType && argType->isVoid()) {
-    auto *argExpr = callExpr->getArg();
-    if (isa<ParenExpr>(argExpr) ||
-        (isa<TupleExpr>(argExpr) &&
-         cast<TupleExpr>(argExpr)->getNumElements() > 0)) {
-      diagnose(callExpr->getLoc(), diag::extra_argument_to_nullary_call)
-          .highlight(argExpr->getSourceRange());
-      return true;
-    }
-  }
-
   // Get the expression result of type checking the arguments to the call
   // independently, so we have some idea of what we're working with.
   //