[Interface] Print private/internal properties

All properties which contribute to the storage of a type should be
printed, and their names should be hidden from interfaces. Print them
with '_' as their name, and teach the parser to recognize these special
patterns when parsing interface files.

Partially resolves rdar://43810647

Author: Harlan Haskins

include/swift/AST/PrintOptions.h

@@ -322,6 +322,9 @@ struct PrintOptions {
   /// for optionals that are nested within other optionals.
   bool PrintOptionalAsImplicitlyUnwrapped = false;
 
+  /// Replaces the name of private and internal properties of types with '_'.
+  bool OmitNameOfInaccessibleProperties = false;
+
   /// \brief Print dependent types as references into this generic environment.
   GenericEnvironment *GenericEnv = nullptr;
 

lib/AST/ASTPrinter.cpp

@@ -64,13 +64,19 @@ void PrintOptions::clearSynthesizedExtension() {
   TransformContext.reset();
 }
 
+static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
+  return ASD->getDeclContext()->isTypeContext() && ASD->hasStorage() &&
+         !ASD->isStatic();
+}
+
 PrintOptions PrintOptions::printTextualInterfaceFile() {
   PrintOptions result;
   result.PrintLongAttrsOnSeparateLines = true;
   result.TypeDefinitions = true;
   result.PrintIfConfig = false;
   result.FullyQualifiedTypes = true;
   result.SkipImports = true;
+  result.OmitNameOfInaccessibleProperties = true;
 
   class ShouldPrintForTextualInterface : public ShouldPrintChecker {
     bool shouldPrint(const Decl *D, const PrintOptions &options) override {
@@ -79,8 +85,14 @@ PrintOptions PrintOptions::printTextualInterfaceFile() {
         AccessScope accessScope =
             VD->getFormalAccessScope(/*useDC*/nullptr,
                                      /*treatUsableFromInlineAsPublic*/true);
-        if (!accessScope.isPublic())
+        if (!accessScope.isPublic()) {
+          // We do want to print private stored properties, without their
+          // original names present.
+          if (auto *ASD = dyn_cast<AbstractStorageDecl>(VD))
+            if (contributesToParentTypeStorage(ASD))
+              return true;
           return false;
+        }
       }
 
       // Skip typealiases that just redeclare generic parameters.
@@ -821,7 +833,13 @@ void PrintAST::printPattern(const Pattern *pattern) {
 
   case PatternKind::Named: {
     auto named = cast<NamedPattern>(pattern);
-    recordDeclLoc(named->getDecl(), [&]{
+    auto decl = named->getDecl();
+    recordDeclLoc(decl, [&]{
+      if (Options.OmitNameOfInaccessibleProperties &&
+          contributesToParentTypeStorage(decl) &&
+          decl->getFormalAccess() < AccessLevel::Public)
+        Printer << "_";
+      else
         Printer.printName(named->getBoundName());
       });
     break;
@@ -1362,6 +1380,12 @@ bool ShouldPrintChecker::shouldPrint(const Decl *D,
     return !EED->getSourceRange().isValid();
   }
 
+  if (auto *ASD = dyn_cast<AbstractStorageDecl>(D)) {
+    if (Options.OmitNameOfInaccessibleProperties &&
+        contributesToParentTypeStorage(ASD))
+      return true;
+  }
+
   // Skip declarations that are not accessible.
   if (auto *VD = dyn_cast<ValueDecl>(D)) {
     if (Options.AccessFilter > AccessLevel::Private &&

lib/Parse/ParsePattern.cpp

@@ -18,6 +18,7 @@
 
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/Module.h"
 #include "swift/Basic/StringExtras.h"
 #include "swift/Parse/CodeCompletionCallbacks.h"
 #include "swift/Parse/SyntaxParsingContext.h"
@@ -907,22 +908,34 @@ ParserResult<Pattern> Parser::parseTypedPattern() {
 ///
 ParserResult<Pattern> Parser::parsePattern() {
   SyntaxParsingContext PatternCtx(SyntaxContext, SyntaxContextKind::Pattern);
+  bool isLet = (InVarOrLetPattern != IVOLP_InVar);
+  auto specifier = isLet
+    ? VarDecl::Specifier::Let
+    : VarDecl::Specifier::Var;
   switch (Tok.getKind()) {
   case tok::l_paren:
     return parsePatternTuple();
 
   case tok::kw__:
+    // Normally, '_' is invalid in type context for patterns, but they show up
+    // in interface files as the name for type members that are non-public.
+    // Treat them as an implicitly synthesized NamedPattern with a nameless
+    // VarDecl inside.
+    if (CurDeclContext->isTypeContext() &&
+        SF.Kind == SourceFileKind::Interface) {
+      PatternCtx.setCreateSyntax(SyntaxKind::IdentifierPattern);
+      auto VD = new (Context) VarDecl(
+        /*IsStatic*/false, specifier, /*IsCaptureList*/false,
+        consumeToken(tok::kw__), Identifier(), CurDeclContext);
+      return makeParserResult(new (Context) NamedPattern(VD, /*implicit*/true));
+    }
     PatternCtx.setCreateSyntax(SyntaxKind::WildcardPattern);
     return makeParserResult(new (Context) AnyPattern(consumeToken(tok::kw__)));
 
   case tok::identifier: {
     PatternCtx.setCreateSyntax(SyntaxKind::IdentifierPattern);
     Identifier name;
     SourceLoc loc = consumeIdentifier(&name);
-    bool isLet = (InVarOrLetPattern != IVOLP_InVar);
-    auto specifier = isLet
-                   ? VarDecl::Specifier::Let
-                   : VarDecl::Specifier::Var;
     if (Tok.isIdentifierOrUnderscore() && !Tok.isContextualDeclKeyword())
       diagnoseConsecutiveIDs(name.str(), loc, isLet ? "constant" : "variable");
 

lib/Sema/TypeCheckDecl.cpp

@@ -946,9 +946,15 @@ static void checkRedeclaration(TypeChecker &tc, ValueDecl *current) {
 /// Does the context allow pattern bindings that don't bind any variables?
 static bool contextAllowsPatternBindingWithoutVariables(DeclContext *dc) {
 
-  // Property decls in type context must bind variables.
-  if (dc->isTypeContext())
+  // Property decls in type context must bind variables unless in a module
+  // interface, where private members don't bind variables but contribute
+  // to storage.
+  if (dc->isTypeContext()) {
+    if (auto SF = dc->getParentSourceFile())
+      if (SF->Kind == SourceFileKind::Interface)
+        return true;
     return false;
+  }
 
   // Global variable decls must bind variables, except in scripts.
   if (dc->isModuleScopeContext()) {

test/ModuleInterface/private-stored-members.swift

@@ -0,0 +1,69 @@
+// RUN: %empty-directory(%t)
+// R UN: %target-swift-frontend -emit-module -o %t/Test~partial.swiftmodule -module-name Test -primary-file %s
+// R UN: %target-swift-frontend -merge-modules -emit-module -o %t/Test.swiftmodule %t/Test~partial.swiftmodule
+// R UN: %target-swift-ide-test -print-module -module-to-print=Test -source-filename=x -I %t | %FileCheck %s
+
+// RUN: %target-swift-frontend -emit-interface-path %t.swiftinterface -enable-resilience -emit-module -o /dev/null %s
+// RUN: %FileCheck %s < %t.swiftinterface
+
+// CHECK: struct MyStruct {{{$}}
+public struct MyStruct {
+// CHECK-NEXT: var publicVar: Int{{$}}
+  public var publicVar: Int
+
+// CHECK-NEXT: let publicLet: Bool{{$}}
+  public let publicLet: Bool
+
+// CHECK-NEXT: internal var _: String{{$}}
+  var internalVar: String
+
+// CHECK-NEXT: internal let _: Bool{{$}}
+  let internalLet: Bool
+
+// CHECK-NEXT: private var _: String{{$}}
+  private var privateVar: String
+
+// CHECK-NEXT: private let _: Bool{{$}}
+  private let privateLet: Bool
+
+// CHECK-NOT: private var
+  private var computedPrivateVar: String {
+    return "computedPrivateVar"
+  }
+
+// CHECK-NOT: private static var
+  private static var staticPrivateVar: String = ""
+
+// CHECK: }{{$}}
+}
+
+// CHECK: class MyClass {{{$}}
+public class MyClass {
+// CHECK-NEXT: public var publicVar: Int{{$}}
+  public var publicVar: Int = 0
+
+// CHECK-NEXT: public let publicLet: Bool{{$}}
+  public let publicLet: Bool = true
+
+// CHECK-NEXT: internal var _: String{{$}}
+  var internalVar: String = ""
+
+// CHECK-NEXT: internal let _: Bool{{$}}
+  let internalLet: Bool = true
+
+// CHECK-NEXT: private var _: String{{$}}
+  private var privateVar: String = ""
+
+// CHECK-NEXT: private let _: Bool{{$}}
+  private let privateLet: Bool = true
+
+// CHECK-NOT: private var
+  private var computedPrivateVar: String {
+    return "computedPrivateVar"
+  }
+
+// CHECK-NOT: private static var
+  private static var staticPrivateVar: String = ""
+
+// CHECK: }{{$}}
+}