[ClangImporter] C static-qualified array params are non-nullable.

lib/ClangImporter/ClangAdapter.cpp

@@ -695,19 +695,28 @@ bool importer::isUnavailableInSwift(
   return false;
 }
 
-OptionalTypeKind importer::getParamOptionality(const clang::ParmVarDecl *param,
+OptionalTypeKind importer::getParamOptionality(version::Version swiftVersion,
+                                               const clang::ParmVarDecl *param,
                                                bool knownNonNull) {
   auto &clangCtx = param->getASTContext();
 
   // If nullability is available on the type, use it.
-  if (auto nullability = param->getType()->getNullability(clangCtx)) {
+  clang::QualType paramTy = param->getType();
+  if (auto nullability = paramTy->getNullability(clangCtx)) {
     return translateNullability(*nullability);
   }
 
   // If it's known non-null, use that.
   if (knownNonNull || param->hasAttr<clang::NonNullAttr>())
     return OTK_None;
 
+  // Check for the 'static' annotation on C arrays.
+  if (!swiftVersion.isVersion3())
+    if (const auto *DT = dyn_cast<clang::DecayedType>(paramTy))
+      if (const auto *AT = DT->getOriginalType()->getAsArrayTypeUnsafe())
+        if (AT->getSizeModifier() == clang::ArrayType::Static)
+          return OTK_None;
+
   // Default to implicitly unwrapped optionals.
   return OTK_ImplicitlyUnwrappedOptional;
 }

lib/ClangImporter/ClangAdapter.h

@@ -139,11 +139,15 @@ bool isUnavailableInSwift(const clang::Decl *decl, const PlatformAvailability &,
 
 /// Determine the optionality of the given Clang parameter.
 ///
+/// \param swiftLanguageVersion What version of Swift we're using, which affects
+/// how optionality is inferred.
+///
 /// \param param The Clang parameter.
 ///
 /// \param knownNonNull Whether a function- or method-level "nonnull" attribute
 /// applies to this parameter.
-OptionalTypeKind getParamOptionality(const clang::ParmVarDecl *param,
+OptionalTypeKind getParamOptionality(version::Version swiftLanguageVersion,
+                                     const clang::ParmVarDecl *param,
                                      bool knownNonNull);
 }
 }

lib/ClangImporter/ImportName.cpp

@@ -713,6 +713,8 @@ static bool omitNeedlessWordsInFunctionName(
     Optional<unsigned> errorParamIndex, bool returnsSelf, bool isInstanceMethod,
     NameImporter &nameImporter) {
   clang::ASTContext &clangCtx = nameImporter.getClangContext();
+  const version::Version &swiftLanguageVersion =
+      nameImporter.getLangOpts().EffectiveLanguageVersion;
 
   // Collect the parameter type names.
   StringRef firstParamName;
@@ -741,7 +743,8 @@ static bool omitNeedlessWordsInFunctionName(
     bool hasDefaultArg =
         ClangImporter::Implementation::inferDefaultArgument(
             param->getType(),
-            getParamOptionality(param, !nonNullArgs.empty() && nonNullArgs[i]),
+            getParamOptionality(swiftLanguageVersion, param,
+                                !nonNullArgs.empty() && nonNullArgs[i]),
             nameImporter.getIdentifier(baseName), numParams, argumentName,
             i == 0, isLastParameter, nameImporter) != DefaultArgumentKind::None;
 

lib/ClangImporter/ImportType.cpp

@@ -1550,7 +1550,8 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
 
     // Check nullability of the parameter.
     OptionalTypeKind OptionalityOfParam =
-        getParamOptionality(param, !nonNullArgs.empty() && nonNullArgs[index]);
+        getParamOptionality(SwiftContext.LangOpts.EffectiveLanguageVersion,
+                            param, !nonNullArgs.empty() && nonNullArgs[index]);
 
     ImportTypeKind importKind = ImportTypeKind::Parameter;
     if (param->hasAttr<clang::CFReturnsRetainedAttr>())
@@ -1933,8 +1934,9 @@ Type ClangImporter::Implementation::importMethodType(
 
     // Check nullability of the parameter.
     OptionalTypeKind optionalityOfParam
-      = getParamOptionality(param,
-                            !nonNullArgs.empty() && nonNullArgs[paramIndex]);
+        = getParamOptionality(SwiftContext.LangOpts.EffectiveLanguageVersion,
+                              param,
+                              !nonNullArgs.empty() && nonNullArgs[paramIndex]);
 
     bool allowNSUIntegerAsIntInParam = isFromSystemModule;
     if (allowNSUIntegerAsIntInParam) {

test/ClangImporter/ctypes_parse.swift

@@ -222,4 +222,9 @@ func testArrays() {
 
   nullableArrayParameters([], [], [])
   nullableArrayParameters(nil, nil, nil)
+
+  // It would also be nice to warn here about the arrays being too short, but
+  // that's probably beyond us for a while.
+  staticBoundsArray([])
+  staticBoundsArray(nil) // no-error
 }

test/ClangImporter/ctypes_parse_swift4.swift

@@ -0,0 +1,10 @@
+// RUN: %target-parse-verify-swift %clang-importer-sdk -swift-version 4
+
+import ctypes
+
+func testArrays() {
+  // It would also be nice to warn here about the arrays being too short, but
+  // that's probably beyond us for a while.
+  staticBoundsArray([])
+  staticBoundsArray(nil) // expected-error {{nil is not compatible with expected argument type 'UnsafePointer<Int8>'}}
+}

test/Inputs/clang-importer-sdk/usr/include/ctypes.h

@@ -265,6 +265,7 @@ typedef struct ModRM {
 // Arrays
 //===---
 void useArray(char x[4], char y[], char z[][8]);
+void staticBoundsArray(const char x[static 4]);
 
 typedef const int FourConstInts[4];
 void nonnullArrayParameters(const char x[_Nonnull], void * const _Nullable y[_Nonnull], _Nonnull FourConstInts z);