Sema: When validating members for layout, skip certain members

For all types, we can safely skip nested nominal types and
typealiases.

For a struct, we only have to look at VarDecls; methods never
affect layout.

Similarly for an enum, only EnumElementDecls matter.

For a class, we still have to look at all methods and properties.
Ideally, in non-optimized builds we would invoke virtual methods
by calling thunks, and only emit the thunks from the translation
unit containing the class. Then the layout of a class will
only be necessary if you subclass the class.

This should improve compiler scalability in multiple-frontend
mode.

Author: slavapestov

Diff for: lib/Sema/TypeChecker.cpp

@@ -407,6 +407,87 @@ void TypeChecker::bindExtension(ExtensionDecl *ext) {
   ::bindExtensionDecl(ext, *this);
 }
 
+static bool shouldValidateDeclForLayout(NominalTypeDecl *nominal, ValueDecl *VD) {
+  // For enums, we only need to validate enum elements to know
+  // the layout.
+  if (isa<EnumDecl>(nominal) &&
+      isa<EnumElementDecl>(VD))
+    return true;
+
+  // For structs, we only need to validate stored properties to
+  // know the layout.
+  if (isa<StructDecl>(nominal) &&
+      (isa<VarDecl>(VD) &&
+       !cast<VarDecl>(VD)->isStatic() &&
+       (cast<VarDecl>(VD)->hasStorage() ||
+        VD->getAttrs().hasAttribute<LazyAttr>())))
+    return true;
+
+  // For classes, we need to validate properties and functions,
+  // but skipping nested types is OK.
+  if (isa<ClassDecl>(nominal) &&
+      !isa<TypeDecl>(VD))
+    return true;
+
+  // For protocols, skip nested typealiases and nominal types.
+  if (isa<ProtocolDecl>(nominal) &&
+      !isa<GenericTypeDecl>(VD))
+    return true;
+
+  return false;
+}
+
+static void validateDeclForLayout(TypeChecker &TC, NominalTypeDecl *nominal) {
+  Optional<bool> lazyVarsAlreadyHaveImplementation;
+
+  for (auto *D : nominal->getMembers()) {
+    auto VD = dyn_cast<ValueDecl>(D);
+    if (!VD)
+      continue;
+
+    if (!shouldValidateDeclForLayout(nominal, VD))
+      continue;
+
+    TC.validateDecl(VD);
+
+    // The only thing left to do is synthesize storage for lazy variables.
+    // We only have to do that if it's a type from another file, though.
+    // In NDEBUG builds, bail out as soon as we can.
+#ifdef NDEBUG
+    if (lazyVarsAlreadyHaveImplementation.hasValue() &&
+        lazyVarsAlreadyHaveImplementation.getValue())
+      continue;
+#endif
+    auto *prop = dyn_cast<VarDecl>(D);
+    if (!prop)
+      continue;
+
+    if (prop->getAttrs().hasAttribute<LazyAttr>() && !prop->isStatic()
+                                                  && prop->getGetter()) {
+      bool hasImplementation = prop->getGetter()->hasBody();
+
+      if (lazyVarsAlreadyHaveImplementation.hasValue()) {
+        assert(lazyVarsAlreadyHaveImplementation.getValue() ==
+                 hasImplementation &&
+               "only some lazy vars already have implementations");
+      } else {
+        lazyVarsAlreadyHaveImplementation = hasImplementation;
+      }
+
+      if (!hasImplementation)
+        TC.completeLazyVarImplementation(prop);
+    }
+  }
+
+  // FIXME: We need to add implicit initializers and dtors when a decl is
+  // touched, because it affects vtable layout.  If you're not defining the
+  // class, you shouldn't have to know what the vtable layout is.
+  if (auto *CD = dyn_cast<ClassDecl>(nominal)) {
+    TC.addImplicitConstructors(CD);
+    TC.addImplicitDestructor(CD);
+  }
+}
+
 static void typeCheckFunctionsAndExternalDecls(TypeChecker &TC) {
   unsigned currentFunctionIdx = 0;
   unsigned currentExternalDef = TC.Context.LastCheckedExternalDefinition;
@@ -462,50 +543,7 @@ static void typeCheckFunctionsAndExternalDecls(TypeChecker &TC) {
       if (nominal->isInvalid() || TC.Context.hadError())
         continue;
 
-      Optional<bool> lazyVarsAlreadyHaveImplementation;
-
-      for (auto *D : nominal->getMembers()) {
-        auto VD = dyn_cast<ValueDecl>(D);
-        if (!VD)
-          continue;
-        TC.validateDecl(VD);
-
-        // The only thing left to do is synthesize storage for lazy variables.
-        // We only have to do that if it's a type from another file, though.
-        // In NDEBUG builds, bail out as soon as we can.
-#ifdef NDEBUG
-        if (lazyVarsAlreadyHaveImplementation.hasValue() &&
-            lazyVarsAlreadyHaveImplementation.getValue())
-          continue;
-#endif
-        auto *prop = dyn_cast<VarDecl>(D);
-        if (!prop)
-          continue;
-
-        if (prop->getAttrs().hasAttribute<LazyAttr>() && !prop->isStatic()
-                                                      && prop->getGetter()) {
-          bool hasImplementation = prop->getGetter()->hasBody();
-
-          if (lazyVarsAlreadyHaveImplementation.hasValue()) {
-            assert(lazyVarsAlreadyHaveImplementation.getValue() ==
-                     hasImplementation &&
-                   "only some lazy vars already have implementations");
-          } else {
-            lazyVarsAlreadyHaveImplementation = hasImplementation;
-          }
-
-          if (!hasImplementation)
-            TC.completeLazyVarImplementation(prop);
-        }
-      }
-
-      // FIXME: We need to add implicit initializers and dtors when a decl is
-      // touched, because it affects vtable layout.  If you're not defining the
-      // class, you shouldn't have to know what the vtable layout is.
-      if (auto *CD = dyn_cast<ClassDecl>(nominal)) {
-        TC.addImplicitConstructors(CD);
-        TC.addImplicitDestructor(CD);
-      }
+      validateDeclForLayout(TC, nominal);
     }
 
     // Complete any conformances that we used.

Diff for: validation-test/compiler_scale/enum_members.gyb

@@ -0,0 +1,20 @@
+// RUN: %scale-test --sum-multi --typecheck --begin 5 --end 16 --step 5 --select validateDecl %s
+// REQUIRES: OS=macosx
+
+enum Enum${N} {
+    case OK
+    case Error
+
+% if int(N) > 1:
+    func method(_: Enum${int(N)-1}) {}
+    static var prop = Enum${int(N)-1}.OK
+    subscript(n: Int) -> Enum${int(N)-1} { return Enum${int(N)-1}.OK }
+% else:
+    func method() {}
+    static var prop = 0
+    subscript(n: Int) -> Int { return 0 }
+% end
+
+    struct Nested {}
+}
+

Diff for: validation-test/compiler_scale/struct_members.gyb

@@ -0,0 +1,18 @@
+// RUN: %scale-test --sum-multi --typecheck --begin 5 --end 16 --step 5 --select validateDecl %s
+// REQUIRES: OS=macosx
+
+struct Struct${N} {
+% if int(N) > 1:
+    func method(_: Struct${int(N)-1}) {}
+    var prop: Struct${int(N)-1} { return Struct${int(N)-1}() }
+    static var prop = Struct${int(N)-1}()
+    subscript(n: Int) -> Struct${int(N)-1} { return Struct${int(N)-1}() }
+% else:
+    func method() {}
+    var prop: Int { return 0 }
+    static var prop = 0
+    subscript(n: Int) -> Int { return 0 }
+% end
+
+    struct Nested {}
+}