[Parse] Stop ignoring private decls for incremental purposes. (#3352)

We'd really like to say that private decls can't affect other files,
but we don't have enough information at parse-time:

- Private members of non-private classes still show up in vtables,
  which affects subclasses and callers in other files.

- Private stored properties of non-private structs change the
  layout of the struct.

- Private types may be used in private stored properties, affecting
  the layout of the containing struct.

- Private decls of /any kind/ can be used as the initial value of a
  stored property without an explicit type.

    private class Evil {
      class func defaultAlignment() -> Alignment { return .evil }
    }
    public struct Character {
      // Inferred type here!
      private var alignment = Evil.defaultAlignment()
    }

To be safe and correct, go back to only ignoring method bodies.

https://bugs.swift.org/browse/SR-1030

Author: jrose-apple

lib/Parse/ParseDecl.cpp

@@ -170,40 +170,6 @@ namespace {
       P.markWasHandled(D);
     }
   };
-
-  /// An RAII type to exclude tokens contributing to private decls from the
-  /// interface hash of the source file. On destruct, it checks if the set of
-  /// attributes includes the "private" attribute; if so, it resets the MD5
-  /// hash of the source file to what it was when the IgnorePrivateDeclTokens
-  /// instance was created, thus excluding from the interface hash all tokens
-  /// parsed in the meantime.
-  struct IgnorePrivateDeclTokens {
-    Parser &TheParser;
-    DeclAttributes &Attributes;
-    Optional<llvm::MD5> SavedHashState;
-
-    IgnorePrivateDeclTokens(Parser &P, DeclAttributes &Attrs)
-      : TheParser(P), Attributes(Attrs) {
-      // NOTE: It's generally not safe to ignore private decls in nominal
-      // types. Such private decls may affect the data layout of a class/struct
-      // or the vtable layout of a class. So only ignore global private decls.
-      if (TheParser.IsParsingInterfaceTokens &&
-          TheParser.CurDeclContext->isModuleScopeContext()) {
-        SavedHashState = TheParser.SF.getInterfaceHashState();
-      }
-    }
-
-    ~IgnorePrivateDeclTokens() {
-      if (!SavedHashState)
-        return;
-
-      if (auto *attr = Attributes.getAttribute<AbstractAccessibilityAttr>()) {
-        if (attr->getAccess() == Accessibility::Private) {
-          TheParser.SF.setInterfaceHashState(*SavedHashState);
-        }
-      }
-    }
-  };
 }
 
 /// \brief Main entrypoint for the parser.
@@ -1905,6 +1871,7 @@ ParserStatus Parser::parseDecl(ParseDeclOptions Flags,
     LastDecl = D;
     Handler(D);
   };
+
   ParserPosition BeginParserPosition;
   if (isCodeCompletionFirstPass())
     BeginParserPosition = getParserPosition();
@@ -1917,7 +1884,6 @@ ParserStatus Parser::parseDecl(ParseDeclOptions Flags,
                                   StructureMarkerKind::Declaration);
 
   DeclAttributes Attributes;
-  IgnorePrivateDeclTokens IgnoreTokens(*this, Attributes);
   if (Tok.hasComment())
     Attributes.add(new (Context) RawDocCommentAttr(Tok.getCommentRange()));
   bool FoundCCTokenInAttr;

test/InterfaceHash/added_private_class_private_property.swift

@@ -0,0 +1,21 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+private class C {
+  func f2() -> Int {
+    return 0
+  }
+}
+
+// BEGIN b.swift
+private class C {
+  func f2() -> Int {
+    return 0
+  }
+
+  private var x: Int = 0
+}

test/InterfaceHash/added_private_enum_private_property.swift

@@ -0,0 +1,23 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+private enum A {
+  case x, y
+  func f2() -> Int {
+    return 0
+  }
+}
+
+// BEGIN b.swift
+private enum A {
+  case x, y
+  func f2() -> Int {
+    return 0
+  }
+
+  var foo: Int { return 0 }
+}

test/InterfaceHash/added_private_enum_property.swift

@@ -0,0 +1,23 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+enum A {
+  case x, y
+  func f2() -> Int {
+    return 0
+  }
+}
+
+// BEGIN b.swift
+enum A {
+  case x, y
+  func f2() -> Int {
+    return 0
+  }
+
+  private var foo: Int { return 0 }
+}

test/InterfaceHash/added_private_method_value_types.swift

@@ -0,0 +1,41 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+struct A {
+  func f2() -> Int {
+    return 0
+  }
+}
+
+enum B {
+  case x, y
+  func f2() -> Int {
+    return 0
+  }
+}
+
+// BEGIN b.swift
+struct A {
+  func f2() -> Int {
+    return 0
+  }
+
+  private func f3() -> Int {
+    return 1
+  }
+}
+
+enum B {
+  case x, y
+  func f2() -> Int {
+    return 0
+  }
+
+  private func f3() -> Int {
+    return 1
+  }
+}

test/InterfaceHash/added_private_protocol_method.swift

@@ -0,0 +1,18 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+private protocol P {
+  func f2() -> Int
+  var y: Int { get set }
+}
+
+// BEGIN b.swift
+private protocol P {
+  func f2() -> Int
+  func f3() -> Int
+  var y: Int { get set }
+}

test/InterfaceHash/added_private_protocol_property.swift

@@ -0,0 +1,18 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+private protocol P {
+  func f2() -> Int
+  var y: Int { get set }
+}
+
+// BEGIN b.swift
+private protocol P {
+  func f2() -> Int
+  var x: Int { get set }
+  var y: Int { get set }
+}

test/InterfaceHash/added_private_struct_private_property.swift

@@ -0,0 +1,24 @@
+// RUN: mkdir -p %t
+// RUN: %utils/split_file.py -o %t %s
+// RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
+// RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
+
+// BEGIN a.swift
+struct S {
+  func f2() -> Int {
+    return 0
+  }
+
+  var y: Int = 0
+}
+
+// BEGIN b.swift
+struct S {
+  func f2() -> Int {
+    return 0
+  }
+
+  private var x: Int = 0
+  var y: Int = 0
+}

test/InterfaceHash/added_private_struct_property.swift

@@ -5,7 +5,7 @@
 // RUN: not cmp %t/a.hash %t/b.hash
 
 // BEGIN a.swift
-struct S {
+private struct S {
   func f2() -> Int {
     return 0
   }
@@ -14,11 +14,11 @@ struct S {
 }
 
 // BEGIN b.swift
-struct S {
+private struct S {
   func f2() -> Int {
     return 0
   }
 
-  private var x: Int = 0
+  var x: Int = 0
   var y: Int = 0
 }

test/InterfaceHash/changed_private_var_type.swift

@@ -2,7 +2,7 @@
 // RUN: %utils/split_file.py -o %t %s
 // RUN: %target-swift-frontend -dump-interface-hash %t/a.swift 2> %t/a.hash
 // RUN: %target-swift-frontend -dump-interface-hash %t/b.swift 2> %t/b.hash
-// RUN: cmp %t/a.hash %t/b.hash
+// RUN: not cmp %t/a.hash %t/b.hash
 
 // BEGIN a.swift
 private var x: Int