Merge pull request #4492 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Parse/Regex.swift

@@ -15,14 +15,14 @@ import AST
 import Basic
 
 #if canImport(_CompilerRegexParser)
-import _CompilerRegexParser
+@_spi(CompilerInterface) import _CompilerRegexParser
 
 public func registerRegexParser() {
   Parser_registerRegexLiteralParsingFn(_RegexLiteralParsingFn)
   Parser_registerRegexLiteralLexingFn(_RegexLiteralLexingFn)
 }
 
-/// Bridging between C++ lexer and _CompilerRegexParser.lexRegex()
+/// Bridging between C++ lexer and swiftCompilerLexRegexLiteral.
 ///
 /// Attempt to lex a regex literal string.
 ///
@@ -50,47 +50,29 @@ private func _RegexLiteralLexingFn(
 ) -> /*CompletelyErroneous*/ CBool {
   let inputPtr = curPtrPtr.pointee
 
-  do {
-    let (_, _, endPtr) = try lexRegex(start: inputPtr, end: bufferEndPtr)
-    curPtrPtr.pointee = endPtr.assumingMemoryBound(to: CChar.self)
+  guard let (resumePtr, error) = swiftCompilerLexRegexLiteral(
+    start: inputPtr, bufferEnd: bufferEndPtr, mustBeRegex: mustBeRegex
+  ) else {
+    // Not a regex literal, fallback without advancing the pointer.
     return false
-  } catch let error as DelimiterLexError {
-    if !mustBeRegex {
-      // This token can be something else. Let the client fallback.
-      return false;
-    }
-    if error.kind == .unknownDelimiter {
-      // An unknown delimiter should be recovered from, as we may want to try
-      // lex something else.
-      return false
-    }
+  }
 
+  // Advance the current pointer.
+  curPtrPtr.pointee = resumePtr.assumingMemoryBound(to: CChar.self)
+
+  if let error = error {
+    // Emit diagnostic if diagnostics are enabled.
     if let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine) {
-      // Emit diagnostic.
       let startLoc = SourceLoc(
-        locationInFile: UnsafeRawPointer(inputPtr).assumingMemoryBound(to: UInt8.self))!
-      diagEngine.diagnose(startLoc, .regex_literal_parsing_error, "\(error)")
-    }
-
-    // Advance the current pointer.
-    curPtrPtr.pointee = error.resumePtr.assumingMemoryBound(to: CChar.self)
-
-    switch error.kind {
-    case .unterminated, .multilineClosingNotOnNewline:
-      // These can be recovered from.
-      return false
-    case .unprintableASCII, .invalidUTF8:
-      // We don't currently have good recovery behavior for these.
-      return true
-    case .unknownDelimiter:
-      fatalError("Already handled")
+        locationInFile: error.location.assumingMemoryBound(to: UInt8.self))!
+      diagEngine.diagnose(startLoc, .regex_literal_parsing_error, error.message)
     }
-  } catch {
-    fatalError("Should be a DelimiterLexError")
+    return error.completelyErroneous
   }
+  return false
 }
 
-/// Bridging between C++ parser and _CompilerRegexParser.parseWithDelimiters()
+/// Bridging between C++ parser and swiftCompilerParseRegexLiteral.
 ///
 /// - Parameters:
 ///   - inputPtr: A null-terminated C string.
@@ -103,6 +85,8 @@ private func _RegexLiteralLexingFn(
 ///     greater than or equal to `strlen(inputPtr)`.
 ///   - bridgedDiagnosticBaseLoc: Source location of the start of the literal
 ///   - bridgedDiagnosticEngine: Diagnostic engine to emit diagnostics.
+///
+/// - Returns: `true` if there was a parse error, `false` otherwise.
 public func _RegexLiteralParsingFn(
   _ inputPtr: UnsafePointer<CChar>,
   _ versionOut: UnsafeMutablePointer<CUnsignedInt>,
@@ -111,30 +95,27 @@ public func _RegexLiteralParsingFn(
   _ bridgedDiagnosticBaseLoc: BridgedSourceLoc,
   _ bridgedDiagnosticEngine: BridgedDiagnosticEngine
 ) -> Bool {
-  versionOut.pointee = currentRegexLiteralFormatVersion
-
   let str = String(cString: inputPtr)
+  let captureBuffer = UnsafeMutableRawBufferPointer(
+    start: captureStructureOut, count: Int(captureStructureSize))
   do {
-    let ast = try parseWithDelimiters(str)
-    // Serialize the capture structure for later type inference.
-    assert(captureStructureSize >= str.utf8.count)
-    let buffer = UnsafeMutableRawBufferPointer(
-        start: captureStructureOut, count: Int(captureStructureSize))
-    ast.captureStructure.encode(to: buffer)
-    return false;
-  } catch {
+    // FIXME: We need to plumb through the 'regexToEmit' result to the caller.
+    // For now, it is the same as the input.
+    let (_, version) = try swiftCompilerParseRegexLiteral(
+      str, captureBufferOut: captureBuffer)
+    versionOut.pointee = CUnsignedInt(version)
+    return false
+  } catch let error as CompilerParseError {
     var diagLoc = SourceLoc(bridged: bridgedDiagnosticBaseLoc)
     let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine)
-    if let _diagLoc = diagLoc,
-       let locatedError = error as? LocatedErrorProtocol {
-      let offset = str.utf8.distance(from: str.startIndex,
-                                     to: locatedError.location.start)
+    if let _diagLoc = diagLoc, let errorLoc = error.location {
+      let offset = str.utf8.distance(from: str.startIndex, to: errorLoc)
       diagLoc = _diagLoc.advanced(by: offset)
     }
-    diagEngine.diagnose(
-      diagLoc, .regex_literal_parsing_error,
-      "cannot parse regular expression: \(String(describing: error))")
+    diagEngine.diagnose(diagLoc, .regex_literal_parsing_error, error.message)
     return true
+  } catch {
+    fatalError("Expected CompilerParseError")
   }
 }
 

include/swift/AST/NameLookup.h

@@ -420,13 +420,17 @@ class AccessFilteringDeclConsumer final : public VisibleDeclConsumer {
 class UsableFilteringDeclConsumer final : public VisibleDeclConsumer {
   const SourceManager &SM;
   const DeclContext *DC;
+  const DeclContext *typeContext;
   SourceLoc Loc;
+  llvm::DenseMap<DeclBaseName, std::pair<ValueDecl *, DeclVisibilityKind>>
+      SeenNames;
   VisibleDeclConsumer &ChainedConsumer;
 
 public:
   UsableFilteringDeclConsumer(const SourceManager &SM, const DeclContext *DC,
                               SourceLoc loc, VisibleDeclConsumer &consumer)
-      : SM(SM), DC(DC), Loc(loc), ChainedConsumer(consumer) {}
+      : SM(SM), DC(DC), typeContext(DC->getInnermostTypeContext()), Loc(loc),
+        ChainedConsumer(consumer) {}
 
   void foundDecl(ValueDecl *D, DeclVisibilityKind reason,
                  DynamicLookupInfo dynamicLookupInfo) override;

include/swift/DependencyScan/SerializedModuleDependencyCacheFormat.h

@@ -51,7 +51,7 @@ using ContextHashField = IdentifierIDField;
 /// A bit that indicates whether or not a module is a framework
 using IsFrameworkField = BCFixed<1>;
 
-/// Arrays of various identifiers, distinguised for readability
+/// Arrays of various identifiers, distinguished for readability
 using IdentifierIDArryField = llvm::BCArray<IdentifierIDField>;
 
 /// Identifiers used to refer to the above arrays
@@ -102,7 +102,7 @@ using IdentifierNodeLayout = BCRecordLayout<IDENTIFIER_NODE, BCBlob>;
 //
 // These arrays are also referenced by their sequence number,
 // starting from 1, similar to identifiers above. Value 0 indicates an
-// empty array. This record is used because individiual array fields must
+// empty array. This record is used because individual array fields must
 // appear as the last field of whatever record they belong to, and several of
 // the below record layouts contain multiple arrays.
 using IdentifierArrayLayout =

include/swift/Sema/ConstraintSystem.h

@@ -4588,6 +4588,7 @@ class ConstraintSystem {
   /// Generate constraints for the given solution target.
   ///
   /// \returns true if an error occurred, false otherwise.
+  LLVM_NODISCARD
   bool generateConstraints(SolutionApplicationTarget &target,
                            FreeTypeVariableBinding allowFreeTypeVariables);
 
@@ -4596,18 +4597,21 @@ class ConstraintSystem {
   /// \param closure the closure expression
   ///
   /// \returns \c true if constraint generation failed, \c false otherwise
+  LLVM_NODISCARD
   bool generateConstraints(ClosureExpr *closure);
 
   /// Generate constraints for the given (unchecked) expression.
   ///
   /// \returns a possibly-sanitized expression, or null if an error occurred.
+  LLVM_NODISCARD
   Expr *generateConstraints(Expr *E, DeclContext *dc,
                             bool isInputExpression = true);
 
   /// Generate constraints for binding the given pattern to the
   /// value of the given expression.
   ///
   /// \returns a possibly-sanitized initializer, or null if an error occurred.
+  LLVM_NODISCARD
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator,
                            bool bindPatternVarsOneWay,
                            PatternBindingDecl *patternBinding,
@@ -4617,6 +4621,7 @@ class ConstraintSystem {
   ///
   /// \returns true if there was an error in constraint generation, false
   /// if generation succeeded.
+  LLVM_NODISCARD
   bool generateConstraints(StmtCondition condition, DeclContext *dc);
 
   /// Generate constraints for a case statement.
@@ -4626,6 +4631,7 @@ class ConstraintSystem {
   ///
   /// \returns true if there was an error in constraint generation, false
   /// if generation succeeded.
+  LLVM_NODISCARD
   bool generateConstraints(CaseStmt *caseStmt, DeclContext *dc,
                            Type subjectType, ConstraintLocator *locator);
 
@@ -4669,6 +4675,7 @@ class ConstraintSystem {
   /// \param propertyType The type of the wrapped property.
   ///
   /// \returns true if there is an error.
+  LLVM_NODISCARD
   bool generateWrappedPropertyTypeConstraints(VarDecl *wrappedVar,
                                               Type initializerType,
                                               Type propertyType);

lib/AST/NameLookup.cpp

@@ -172,18 +172,150 @@ void UsableFilteringDeclConsumer::foundDecl(ValueDecl *D,
 
   switch (reason) {
   case DeclVisibilityKind::LocalVariable:
-    // Skip if Loc is before the found decl, unless its a TypeDecl (whose use
-    // before its declaration is still allowed)
-    if (!isa<TypeDecl>(D) && !SM.isBeforeInBuffer(D->getLoc(), Loc))
+  case DeclVisibilityKind::FunctionParameter:
+    // Skip if Loc is before the found decl if the decl is a var/let decl.
+    // Type and func decls can be referenced before its declaration, or from
+    // within nested type decls.
+    if (isa<VarDecl>(D)) {
+      if (reason == DeclVisibilityKind::LocalVariable) {
+        // Workaround for fast-completion. A loc in the current context might be
+        // in a loc
+        auto tmpLoc = Loc;
+        if (D->getDeclContext() != DC) {
+          if (auto *contextD = DC->getAsDecl())
+            tmpLoc = contextD->getStartLoc();
+        }
+        if (!SM.isBeforeInBuffer(D->getLoc(), Loc))
+          return;
+      }
+
+      // A type context cannot close over values defined in outer type contexts.
+      if (D->getDeclContext()->getInnermostTypeContext() != typeContext)
+        return;
+    }
+    break;
+
+  case DeclVisibilityKind::MemberOfOutsideNominal:
+    // A type context cannot close over members of outer type contexts, except
+    // for type decls.
+    if (!isa<TypeDecl>(D) && !D->isStatic())
       return;
     break;
-  default:
+
+  case DeclVisibilityKind::MemberOfCurrentNominal:
+  case DeclVisibilityKind::MemberOfSuper:
+  case DeclVisibilityKind::MemberOfProtocolConformedToByCurrentNominal:
+  case DeclVisibilityKind::MemberOfProtocolDerivedByCurrentNominal:
+  case DeclVisibilityKind::DynamicLookup:
+    // Members on 'Self' including inherited/derived ones are always usable.
+    break;
+
+  case DeclVisibilityKind::GenericParameter:
+    // Generic params are type decls and are always usable from nested context.
+    break;
+
+  case DeclVisibilityKind::VisibleAtTopLevel:
     // The rest of the file is currently skipped, so no need to check
-    // decl location for VisibleAtTopLevel. Other visibility kinds are always
-    // usable
+    // decl location for VisibleAtTopLevel.
     break;
   }
 
+  // Filter out shadowed decls. Do this for only usable values even though
+  // unusable values actually can shadow outer values, because compilers might
+  // be able to diagnose it with fix-it to add the qualification. E.g.
+  //   func foo(global: T) {}
+  //   struct Outer {
+  //     func foo(outer: T) {}
+  //     func test() {
+  //       struct Inner {
+  //         func test() {
+  //           <HERE>
+  //         }
+  //       }
+  //     }
+  //   }
+  // In this case 'foo(global:)' is shadowed by 'foo(outer:)', but 'foo(outer:)'
+  // is _not_ usable because it's outside the current type context, whereas
+  // 'foo(global:)' is still usable with 'ModuleName.' qualification.
+  // FIXME: (for code completion,) If a global value or a static type member is
+  // shadowd, we should suggest it with prefix (e.g. 'ModuleName.value').
+  auto inserted = SeenNames.insert({D->getBaseName(), {D, reason}});
+  if (!inserted.second) {
+    auto shadowingReason = inserted.first->second.second;
+    auto *shadowingD = inserted.first->second.first;
+
+    // A type decl cannot have overloads, and shadows everything outside the
+    // scope.
+    if (isa<TypeDecl>(shadowingD))
+      return;
+
+    switch (shadowingReason) {
+    case DeclVisibilityKind::LocalVariable:
+    case DeclVisibilityKind::FunctionParameter:
+      // Local func and var/let with a conflicting name.
+      //   func foo() {
+      //     func value(arg: Int) {}
+      //     var value = ""
+      //   }
+      // In this case, 'var value' wins, regardless of their source order.
+      // So, for confilicting local values in the same decl context, even if the
+      // 'var value' is reported after 'func value', don't shadow it, but we
+      // shadow everything with the name after that.
+      if (reason == DeclVisibilityKind::LocalVariable &&
+          isa<VarDecl>(D) && !isa<VarDecl>(shadowingD) &&
+          shadowingD->getDeclContext() == D->getDeclContext()) {
+        // Replace the shadowing decl so we shadow subsequent conflicting decls.
+        inserted.first->second = {D, reason};
+        break;
+      }
+
+      // Otherwise, a local value shadows everything outside the scope.
+      return;
+
+    case DeclVisibilityKind::GenericParameter:
+      // A Generic parameter is a type name. It shadows everything outside the
+      // generic context.
+      return;
+
+    case DeclVisibilityKind::MemberOfCurrentNominal:
+    case DeclVisibilityKind::MemberOfSuper:
+    case DeclVisibilityKind::MemberOfProtocolConformedToByCurrentNominal:
+    case DeclVisibilityKind::MemberOfProtocolDerivedByCurrentNominal:
+    case DeclVisibilityKind::DynamicLookup:
+      switch (reason) {
+      case DeclVisibilityKind::MemberOfCurrentNominal:
+      case DeclVisibilityKind::MemberOfSuper:
+      case DeclVisibilityKind::MemberOfProtocolConformedToByCurrentNominal:
+      case DeclVisibilityKind::MemberOfProtocolDerivedByCurrentNominal:
+      case DeclVisibilityKind::DynamicLookup:
+        // Members on the current type context don't shadow members with the
+        // same base name on the current type contxt. They are overloads.
+        break;
+      default:
+        // Members of a type context shadows values/types outside.
+        return;
+      }
+      break;
+
+    case DeclVisibilityKind::MemberOfOutsideNominal:
+      // For static values, it's unclear _which_ type context (i.e. this type,
+      // super classes, conforming protocols) this decl was found in. For now,
+      // consider all the outer nominals are the same.
+
+      if (reason == DeclVisibilityKind::MemberOfOutsideNominal)
+        break;
+
+      // Values outside the nominal are shadowed.
+      return;
+
+    case DeclVisibilityKind::VisibleAtTopLevel:
+      // Top level decls don't shadow anything.
+      // Well, that's not true. Decls in the current module shadows decls in
+      // the imported modules. But we don't care them here.
+      break;
+    }
+  }
+
   ChainedConsumer.foundDecl(D, reason, dynamicLookupInfo);
 }