diff --git a/closure/compiler/closure_js_aspect.bzl b/closure/compiler/closure_js_aspect.bzl
index 1e0ea0020f..dc0b0d8959 100644
--- a/closure/compiler/closure_js_aspect.bzl
+++ b/closure/compiler/closure_js_aspect.bzl
@@ -15,6 +15,8 @@
 load(
     "//closure/private:defs.bzl",
     "CLOSURE_WORKER_ATTR",
+    "ClosureJsLegacyRunfilesInfo",
+    "ClosureJsLibraryInfo",
     "JS_FILE_TYPE",
     "collect_js",
     "collect_runfiles",
@@ -26,13 +28,13 @@ load(
 )
 
 def _closure_js_aspect_impl(target, ctx):
-    if hasattr(target, "closure_js_library"):
-        return struct()
+    if ClosureJsLibraryInfo in target:
+        return []
 
     # This aspect is currently a no-op in the open source world. We intend to add
     # content to it in the future. It is still provided to ensure the Skylark API
     # is well defined.
-    return struct()
+    return []
 
 closure_js_aspect = aspect(
     implementation = _closure_js_aspect_impl,
diff --git a/closure/compiler/closure_js_binary.bzl b/closure/compiler/closure_js_binary.bzl
index 6ca0d4bcff..2298937123 100644
--- a/closure/compiler/closure_js_binary.bzl
+++ b/closure/compiler/closure_js_binary.bzl
@@ -17,6 +17,9 @@
 load(
     "//closure/private:defs.bzl",
     "CLOSURE_JS_TOOLCHAIN_ATTRS",
+    "ClosureCssBinaryInfo",
+    "ClosureJsBinaryInfo",
+    "ClosureJsLibraryInfo",
     "JS_LANGUAGES",
     "JS_LANGUAGE_IN",
     "JS_LANGUAGE_OUT_DEFAULT",
@@ -78,7 +81,7 @@ def _impl(ctx):
             ", ".join(JS_LANGUAGES.to_list()),
         ))
 
-    deps = unfurl(ctx.attr.deps, provider = "closure_js_library")
+    deps = unfurl(ctx.attr.deps, provider = ClosureJsLibraryInfo).exports
     js = collect_js(deps, ctx.attr._closure_library_base, css = ctx.attr.css)
     if not js.srcs:
         fail("There are no JS source files in the transitive closure")
@@ -281,27 +284,26 @@ def _impl(ctx):
     # promise to compile. Its fulfillment is the prerogative of ancestors which
     # are free to ignore the binary in favor of the raw sauces propagated by the
     # closure_js_library provider, in which case, no compilation is performed.
-    return struct(
-        files = depset(files),
-        closure_js_library = js,
-        closure_js_binary = struct(
+    return [
+        ClosureJsBinaryInfo(
             bin = ctx.outputs.bin,
             map = ctx.outputs.map,
             language = ctx.attr.language,
         ),
-        runfiles = ctx.runfiles(
+        js,
+        DefaultInfo(files = depset(files), runfiles = ctx.runfiles(
             files = files + ctx.files.data,
             transitive_files = depset(transitive = [
                 collect_runfiles(deps),
                 collect_runfiles([ctx.attr.css]),
                 collect_runfiles(ctx.attr.data),
             ]),
-        ),
-    )
+        )),
+    ]
 
 def _validate_css_graph(ctx, js):
     if ctx.attr.css:
-        missing = difference(js.stylesheets, ctx.attr.css.closure_css_binary.labels)
+        missing = difference(js.stylesheets, ctx.attr.css[ClosureCssBinaryInfo].labels)
         if missing:
             fail("Dependent JS libraries depend on CSS libraries that weren't " +
                  "compiled into the referenced CSS binary: " +
@@ -315,7 +317,7 @@ closure_js_binary = rule(
     implementation = _impl,
     attrs = dict({
         "compilation_level": attr.string(default = "ADVANCED"),
-        "css": attr.label(providers = ["closure_css_binary"]),
+        "css": attr.label(providers = [ClosureCssBinaryInfo]),
         "debug": attr.bool(default = False),
         "defs": attr.string_list(),
         # TODO(tjgq): Remove the deprecated STRICT/LOOSE in favor of PRUNE/PRUNE_LEGACY.
@@ -332,7 +334,7 @@ closure_js_binary = rule(
         ),
         "deps": attr.label_list(
             aspects = [closure_js_aspect],
-            providers = ["closure_js_library"],
+            providers = [ClosureJsLibraryInfo],
         ),
         "entry_points": attr.string_list(),
         "formatting": attr.string(),
diff --git a/closure/compiler/closure_js_library.bzl b/closure/compiler/closure_js_library.bzl
index bfb93b712c..828c8fc8a5 100644
--- a/closure/compiler/closure_js_library.bzl
+++ b/closure/compiler/closure_js_library.bzl
@@ -17,6 +17,8 @@
 load(
     "//closure/private:defs.bzl",
     "CLOSURE_JS_TOOLCHAIN_ATTRS",
+    "ClosureCssLibraryInfo",
+    "ClosureJsLibraryInfo",
     "JS_FILE_TYPE",
     "JS_LANGUAGE_IN",
     "collect_js",
@@ -163,7 +165,7 @@ def _closure_js_library_impl(
 
     # Create a list of direct children of this rule. If any direct dependencies
     # have the exports attribute, those labels become direct dependencies here.
-    deps = unfurl(deps, provider = "closure_js_library")
+    deps = unfurl(deps, provider = ClosureJsLibraryInfo).exports
 
     # Collect all the transitive stuff the child rules have propagated. Bazel has
     # a special nested set data structure that makes this efficient.
@@ -177,7 +179,7 @@ def _closure_js_library_impl(
     # which is a superset of the CSS libraries in its transitive closure.
     stylesheets = []
     for dep in deps:
-        if hasattr(dep, "closure_css_library"):
+        if ClosureCssLibraryInfo in dep:
             stylesheets.append(dep.label)
 
     # JsChecker is a program that's run via the ClosureWorker persistent Bazel
@@ -263,7 +265,7 @@ def _closure_js_library_impl(
     info_files = []
     for dep in deps:
         # Polymorphic rules, e.g. closure_css_library, might not provide this.
-        info = getattr(dep.closure_js_library, "info", None)
+        info = getattr(dep[ClosureJsLibraryInfo], "info", None)
         if info:
             args.add("--dep", info)
             info_files.append(info)
@@ -303,7 +305,7 @@ def _closure_js_library_impl(
     # interface because other Skylark rules can be designed to do things with
     # this data. Other Skylark rules can even export their own provider with the
     # same name to become polymorphically compatible with this one.
-    return struct(
+    return [
         # Iterable<Target> of deps that should only become deps in parent rules.
         # Exports are not deps of the Target to which they belong. The exports
         # provider does not contain the exports its deps export. Targets in this
@@ -320,10 +322,10 @@ def _closure_js_library_impl(
         # the exports attribute does not exist. The exports feature can be abused
         # by users to circumvent strict deps checking and therefore should be
         # used with caution.
-        exports = unfurl(exports),
+        unfurl(exports),
         # All of the subproviders below are considered optional and MUST be
         # accessed using getattr(x, y, default). See collect_js() in defs.bzl.
-        closure_js_library = struct(
+        ClosureJsLibraryInfo(
             # File pointing to a ClosureJsLibrary protobuf file in pbtxt format
             # that's generated by this specific Target. It contains some metadata
             # as well as information extracted from inside the srcs files, e.g.
@@ -366,7 +368,7 @@ def _closure_js_library_impl(
             # of the srcs subprovider. This field exists for optimization.
             has_closure_library = js.has_closure_library,
         ),
-    )
+    ]
 
 def _closure_js_library(ctx):
     if not ctx.files.srcs and not ctx.files.externs and not ctx.attr.exports:
@@ -407,22 +409,22 @@ def _closure_js_library(ctx):
         ctx.outputs.typecheck,
     )
 
-    return struct(
-        files = depset(),
-        exports = library.exports,
-        closure_js_library = library.closure_js_library,
-        # The usual suspects are exported as runfiles, in addition to raw source.
-        runfiles = ctx.runfiles(
-            files = srcs + ctx.files.data,
-            transitive_files = depset(
-                transitive = [
-                    collect_runfiles(unfurl(ctx.attr.deps, provider = "closure_js_library")),
-                    collect_runfiles(ctx.attr.data),
-                    collect_runfiles(library.exports),
-                ],
+    return library + [
+        DefaultInfo(
+            files = depset(),
+            # The usual suspects are exported as runfiles, in addition to raw source.
+            runfiles = ctx.runfiles(
+                files = srcs + ctx.files.data,
+                transitive_files = depset(
+                    transitive = [
+                        collect_runfiles(unfurl(ctx.attr.deps, provider = ClosureJsLibraryInfo).exports),
+                        collect_runfiles(ctx.attr.data),
+                        collect_runfiles(unfurl(ctx.attr.exports).exports),
+                    ],
+                ),
             ),
         ),
-    )
+    ]
 
 closure_js_library = rule(
     implementation = _closure_js_library,
@@ -435,11 +437,11 @@ closure_js_library = rule(
         "data": attr.label_list(allow_files = True),
         "deps": attr.label_list(
             aspects = [closure_js_aspect],
-            providers = ["closure_js_library"],
+            providers = [ClosureJsLibraryInfo],
         ),
         "exports": attr.label_list(
             aspects = [closure_js_aspect],
-            providers = ["closure_js_library"],
+            providers = [ClosureJsLibraryInfo],
         ),
         "includes": attr.string_list(),
         "no_closure_library": attr.bool(),
diff --git a/closure/private/defs.bzl b/closure/private/defs.bzl
index 659446a98e..806c623970 100644
--- a/closure/private/defs.bzl
+++ b/closure/private/defs.bzl
@@ -61,6 +61,84 @@ CLOSURE_JS_TOOLCHAIN_ATTRS = {
     "_unusable_type_definition": UNUSABLE_TYPE_DEFINITION,
 }
 
+ClosureJsLibraryInfo = provider("ClosureJsLibraryInfo", fields = {
+    "info": """
+File pointing to a ClosureJsLibrary protobuf file in pbtxt format
+that's generated by this specific Target. It contains some metadata
+as well as information extracted from inside the srcs files, e.g.
+goog.provide'd namespaces. It is used for strict dependency
+checking, a.k.a. layering checks.
+""",
+    "infos": """
+NestedSet<File> of all info files in the transitive closure. This
+is used by JsCompiler to apply error suppression on a file-by-file
+basis.""",
+    "ijs": "",
+    "ijs_files": "",
+    "srcs": """
+NestedSet<File> of all JavaScript source File artifacts in the
+transitive closure. These files MUST be JavaScript.""",
+    "js_module_roots": """
+NestedSet<String> of all execroot path prefixes in the transitive
+closure. For very simple projects, it will be empty. It is useful
+for getting rid of Bazel generated directories, workspace names,
+etc. out of module paths.  It contains the cartesian product of
+generated roots, external repository roots, and includes
+prefixes. This is passed to JSCompiler via the --js_module_root
+flag. See find_js_module_roots() in defs.bzl.            """,
+    "modules": """
+NestedSet<String> of all ES6 module name strings in the transitive
+closure. These are generated from the source file path relative to
+the longest matching root prefix. It is used to guarantee that
+within any given transitive closure, no namespace collisions
+exist. These MUST NOT begin with "/" or ".", or contain "..".""",
+    "descriptors": """
+NestedSet<File> of all protobuf definitions in the transitive
+closure. It is used so Closure Templates can have information about
+the structure of protobufs so they can be easily rendered in .soy
+files with type safety. See closure_js_template_library.bzl.""",
+    "stylesheets": """
+NestedSet<Label> of all closure_css_library rules in the transitive
+closure. This is used by closure_js_binary can guarantee the
+completeness of goog.getCssName() substitutions.""",
+    "has_closure_library": """
+Boolean indicating indicating if Closure Library's base.js is part
+of the srcs subprovider. This field exists for optimization.""",
+    "language": "",
+})
+
+ClosureExportsInfo = provider("ClosureExportsInfo", fields = {"exports": """
+Iterable<Target> of deps that should only become deps in parent rules.
+Exports are not deps of the Target to which they belong. The exports
+provider does not contain the exports its deps export. Targets in this
+provider are not necessarily guaranteed to have a closure_js_library
+provider. Rules allowing closure_js_library deps MUST also treat
+exports of those deps as direct dependencies of the Target. If those
+rules are library rules, then they SHOULD also provide an exports
+attribute of their own which is propagated to parent targets via the
+exports provider, along with any exports those exports export. The
+exports attribute MUST NOT contain files and SHOULD NOT impose
+restrictions on what providers a Target must have. Rules exporting this
+provider MUST NOT allow deps to be set if srcs is empty. Aspects
+exporting this provider MAY turn deps into exports if srcs is empty and
+the exports attribute does not exist. The exports feature can be abused
+by users to circumvent strict deps checking and therefore should be
+used with caution."""})
+
+ClosureJsBinaryInfo = provider("ClosureJsBinaryInfo", fields = ["bin", "map", "language"])
+ClosureCssBinaryInfo = provider("ClosureCssBinaryInfo", fields = ["bin", "map", "renaming_map", "labels"])
+
+ClosureCssLibraryInfo = provider("ClosureCssLibraryInfo", fields = [
+    "srcs",
+    "labels",
+    "transitive",
+    "orientation",
+])
+
+ClosureJsLegacyRunfilesInfo = provider("ClosureJsLegacyRunfilesInfo", fields = ["runfiles"])
+
+WebFilesInfo = provider("WebFilesInfo", fields = ["manifest", "manifests", "webpaths", "dummy"])
+
 def get_jsfile_path(f):
     """Returns the file path for a JavaScript file, otherwise None.
 
@@ -74,13 +152,13 @@ def unfurl(deps, provider = ""):
     """Returns deps as well as deps exported by parent rules."""
     res = []
     for dep in deps:
-        if not provider or hasattr(dep, provider):
+        if not provider or provider in dep:
             res.append(dep)
-        if hasattr(dep, "exports"):
-            for edep in dep.exports:
-                if not provider or hasattr(edep, provider):
+        if ClosureExportsInfo in dep:
+            for edep in dep[ClosureExportsInfo].exports:
+                if not provider or provider in edep:
                     res.append(edep)
-    return res
+    return ClosureExportsInfo(exports = res)
 
 def collect_js(
         deps,
@@ -98,16 +176,16 @@ def collect_js(
     js_module_roots = []
     has_closure_library = False
     for dep in deps:
-        srcs += [getattr(dep.closure_js_library, "srcs", depset())]
-        ijs_files += [getattr(dep.closure_js_library, "ijs_files", depset())]
-        infos += [getattr(dep.closure_js_library, "infos", depset())]
-        modules += [getattr(dep.closure_js_library, "modules", depset())]
-        descriptors += [getattr(dep.closure_js_library, "descriptors", depset())]
-        stylesheets += [getattr(dep.closure_js_library, "stylesheets", depset())]
-        js_module_roots += [getattr(dep.closure_js_library, "js_module_roots", depset())]
+        srcs += [getattr(dep[ClosureJsLibraryInfo], "srcs", depset())]
+        ijs_files += [getattr(dep[ClosureJsLibraryInfo], "ijs_files", depset())]
+        infos += [getattr(dep[ClosureJsLibraryInfo], "infos", depset())]
+        modules += [getattr(dep[ClosureJsLibraryInfo], "modules", depset())]
+        descriptors += [getattr(dep[ClosureJsLibraryInfo], "descriptors", depset())]
+        stylesheets += [getattr(dep[ClosureJsLibraryInfo], "stylesheets", depset())]
+        js_module_roots += [getattr(dep[ClosureJsLibraryInfo], "js_module_roots", depset())]
         has_closure_library = (
             has_closure_library or
-            getattr(dep.closure_js_library, "has_closure_library", False)
+            getattr(dep[ClosureJsLibraryInfo], "has_closure_library", False)
         )
     if no_closure_library:
         if has_closure_library:
@@ -117,9 +195,9 @@ def collect_js(
         has_closure_library = True
 
     if css:
-        direct_srcs += [css.closure_css_binary.renaming_map]
+        direct_srcs += [css[ClosureCssBinaryInfo].renaming_map]
 
-    return struct(
+    return ClosureJsLibraryInfo(
         srcs = depset(direct_srcs, transitive = srcs),
         js_module_roots = depset(transitive = js_module_roots),
         ijs_files = depset(transitive = ijs_files),
@@ -135,14 +213,14 @@ def collect_css(deps, orientation = None):
     srcs = []
     labels = []
     for dep in deps:
-        if hasattr(dep.closure_css_library, "srcs"):
-            srcs.append(getattr(dep.closure_css_library, "srcs"))
-        if hasattr(dep.closure_css_library, "labels"):
-            labels.append(getattr(dep.closure_css_library, "labels"))
+        if hasattr(dep[ClosureCssLibraryInfo], "srcs"):
+            srcs.append(getattr(dep[ClosureCssLibraryInfo], "srcs"))
+        if hasattr(dep[ClosureCssLibraryInfo], "labels"):
+            labels.append(getattr(dep[ClosureCssLibraryInfo], "labels"))
         if orientation:
-            if dep.closure_css_library.orientation != orientation:
+            if dep[ClosureCssLibraryInfo].orientation != orientation:
                 fail("%s does not have the same orientation" % dep.label)
-        orientation = dep.closure_css_library.orientation
+        orientation = dep[ClosureCssLibraryInfo].orientation
     return struct(
         srcs = depset(transitive = srcs),
         labels = depset(transitive = labels),
@@ -153,8 +231,8 @@ def collect_runfiles(targets):
     """Aggregates data runfiles from targets."""
     data = []
     for target in targets:
-        if hasattr(target, "closure_legacy_js_runfiles"):
-            data.append(target.closure_legacy_js_runfiles)
+        if target and ClosureJsLegacyRunfilesInfo in target:
+            data.append(target[ClosureJsLegacyRunfilesInfo].runfiles)
             continue
         if hasattr(target, "runfiles"):
             data.append(target.runfiles.files)
diff --git a/closure/protobuf/closure_proto_library.bzl b/closure/protobuf/closure_proto_library.bzl
index 24238155a0..274ba5b7a3 100644
--- a/closure/protobuf/closure_proto_library.bzl
+++ b/closure/protobuf/closure_proto_library.bzl
@@ -17,7 +17,7 @@
 
 load("@rules_proto//proto:defs.bzl", "ProtoInfo")
 load("//closure/compiler:closure_js_library.bzl", "create_closure_js_library")
-load("//closure/private:defs.bzl", "CLOSURE_JS_TOOLCHAIN_ATTRS", "unfurl")
+load("//closure/private:defs.bzl", "CLOSURE_JS_TOOLCHAIN_ATTRS", "ClosureJsLibraryInfo", "unfurl")
 
 def _generate_closure_js_progress_message(name):
     # TODO(yannic): Add a better message?
@@ -61,7 +61,7 @@ def _closure_proto_aspect_impl(target, ctx):
     js = _generate_closure_js(target, ctx)
 
     srcs = depset([js])
-    deps = unfurl(ctx.rule.attr.deps, provider = "closure_js_library")
+    deps = unfurl(ctx.rule.attr.deps, provider = ClosureJsLibraryInfo).exports
     deps += [ctx.attr._closure_library, ctx.attr._closure_protobuf_jspb]
 
     suppress = [
@@ -70,12 +70,7 @@ def _closure_proto_aspect_impl(target, ctx):
     ]
 
     library = create_closure_js_library(ctx, srcs, deps, [], suppress, True)
-    return struct(
-        exports = library.exports,
-        closure_js_library = library.closure_js_library,
-        # The usual suspects are exported as runfiles, in addition to raw source.
-        runfiles = ctx.runfiles(files = [js]),
-    )
+    return library
 
 closure_proto_aspect = aspect(
     attr_aspects = ["deps"],
@@ -108,11 +103,7 @@ def _closure_proto_library_impl(ctx):
         fail(_error_multiple_deps, "deps")
 
     dep = ctx.attr.deps[0]
-    return struct(
-        files = depset(),
-        exports = dep.exports,
-        closure_js_library = dep.closure_js_library,
-    )
+    return [dep[ClosureJsLibraryInfo], DefaultInfo(files = depset())]
 
 closure_proto_library = rule(
     attrs = {
diff --git a/closure/stylesheets/closure_css_binary.bzl b/closure/stylesheets/closure_css_binary.bzl
index d4e42a49f8..d75b27499e 100644
--- a/closure/stylesheets/closure_css_binary.bzl
+++ b/closure/stylesheets/closure_css_binary.bzl
@@ -17,6 +17,8 @@
 
 load(
     "//closure/private:defs.bzl",
+    "ClosureCssBinaryInfo",
+    "ClosureCssLibraryInfo",
     "collect_css",
     "collect_runfiles",
     "unfurl",
@@ -25,7 +27,7 @@ load(
 def _closure_css_binary(ctx):
     if not ctx.attr.deps:
         fail("closure_css_binary rules can not have an empty 'deps' list")
-    deps = unfurl(ctx.attr.deps, provider = "closure_css_library")
+    deps = unfurl(ctx.attr.deps, provider = ClosureCssLibraryInfo).exports
     css = collect_css(deps)
     if not css.srcs:
         fail("There are no CSS source files in the transitive closure")
@@ -77,32 +79,34 @@ def _closure_css_binary(ctx):
             ctx.outputs.bin.short_path,
         ),
     )
-    return struct(
-        files = depset(files),
-        closure_css_binary = struct(
+    return [
+        ClosureCssBinaryInfo(
             bin = ctx.outputs.bin,
             map = ctx.outputs.map,
             renaming_map = ctx.outputs.js,
             labels = css.labels,
         ),
-        closure_css_library = struct(
+        ClosureCssLibraryInfo(
             srcs = depset([ctx.outputs.bin]),
             orientation = (css.orientation if ctx.attr.orientation == "NOCHANGE" else ctx.attr.orientation),
         ),
-        runfiles = ctx.runfiles(
-            files = files + ctx.files.data,
-            transitive_files = depset(
-                transitive = [collect_runfiles(deps), collect_runfiles(ctx.attr.data)],
+        DefaultInfo(
+            files = depset(files),
+            runfiles = ctx.runfiles(
+                files = files + ctx.files.data,
+                transitive_files = depset(
+                    transitive = [collect_runfiles(deps), collect_runfiles(ctx.attr.data)],
+                ),
             ),
         ),
-    )
+    ]
 
 closure_css_binary = rule(
     implementation = _closure_css_binary,
     attrs = {
         "debug": attr.bool(),
         "defs": attr.string_list(),
-        "deps": attr.label_list(providers = ["closure_css_library"]),
+        "deps": attr.label_list(providers = [ClosureCssLibraryInfo]),
         "orientation": attr.string(default = "NOCHANGE"),
         "renaming": attr.bool(default = True),
         "vendor": attr.string(),
diff --git a/closure/stylesheets/closure_css_library.bzl b/closure/stylesheets/closure_css_library.bzl
index 8ac3b6be26..95e0e2c54b 100644
--- a/closure/stylesheets/closure_css_library.bzl
+++ b/closure/stylesheets/closure_css_library.bzl
@@ -17,37 +17,41 @@
 load(
     "//closure/private:defs.bzl",
     "CSS_FILE_TYPE",
+    "ClosureCssLibraryInfo",
+    "ClosureJsLibraryInfo",
     "collect_css",
     "collect_runfiles",
     "unfurl",
 )
 
 def _closure_css_library(ctx):
-    deps = unfurl(ctx.attr.deps, provider = "closure_css_library")
+    deps = unfurl(ctx.attr.deps, provider = ClosureCssLibraryInfo).exports
     css = collect_css(deps, ctx.attr.orientation)
-    return struct(
-        files = depset(),
-        exports = unfurl(ctx.attr.exports),
-        closure_js_library = struct(),
-        closure_css_library = struct(
+    return [
+        ClosureCssLibraryInfo(
             srcs = depset(ctx.files.srcs, transitive = [css.srcs]),
             labels = depset([ctx.label], transitive = [css.labels]),
             orientation = ctx.attr.orientation,
         ),
-        runfiles = ctx.runfiles(
-            files = ctx.files.srcs + ctx.files.data,
-            transitive_files = depset(
-                transitive = [collect_runfiles(deps), collect_runfiles(ctx.attr.data)],
+        unfurl(ctx.attr.exports),
+        ClosureJsLibraryInfo(),
+        DefaultInfo(
+            files = depset(),
+            runfiles = ctx.runfiles(
+                files = ctx.files.srcs + ctx.files.data,
+                transitive_files = depset(
+                    transitive = [collect_runfiles(deps), collect_runfiles(ctx.attr.data)],
+                ),
             ),
         ),
-    )
+    ]
 
 closure_css_library = rule(
     implementation = _closure_css_library,
     attrs = {
         "srcs": attr.label_list(allow_files = CSS_FILE_TYPE),
         "data": attr.label_list(allow_files = True),
-        "deps": attr.label_list(providers = ["closure_css_library"]),
+        "deps": attr.label_list(providers = [ClosureCssLibraryInfo]),
         "exports": attr.label_list(),
         "orientation": attr.string(default = "LTR"),
     },
diff --git a/closure/templates/closure_js_template_library.bzl b/closure/templates/closure_js_template_library.bzl
index 08397af0ca..46509d7869 100644
--- a/closure/templates/closure_js_template_library.bzl
+++ b/closure/templates/closure_js_template_library.bzl
@@ -17,7 +17,7 @@
 
 load("//closure/compiler:closure_js_aspect.bzl", "closure_js_aspect")
 load("//closure/compiler:closure_js_library.bzl", "closure_js_library")
-load("//closure/private:defs.bzl", "SOY_FILE_TYPE", "unfurl")
+load("//closure/private:defs.bzl", "ClosureJsLibraryInfo", "SOY_FILE_TYPE", "unfurl")
 load("//closure/templates:closure_templates_plugin.bzl", "SoyPluginInfo")
 
 _SOYTOJSSRCCOMPILER = "@com_google_template_soy//:SoyToJsSrcCompiler"
@@ -47,8 +47,8 @@ def _impl(ctx):
     if ctx.file.globals:
         args += ["--compileTimeGlobalsFile", ctx.file.globals.path]
         inputs.append(ctx.file.globals)
-    for dep in unfurl(ctx.attr.deps, provider = "closure_js_library"):
-        for f in dep.closure_js_library.descriptors.to_list():
+    for dep in unfurl(ctx.attr.deps, provider = ClosureJsLibraryInfo).exports:
+        for f in dep[ClosureJsLibraryInfo].descriptors.to_list():
             args += ["--protoFileDescriptors=%s" % f.path]
             inputs.append(f)
 
@@ -79,7 +79,7 @@ _closure_js_template_library = rule(
         "srcs": attr.label_list(allow_files = SOY_FILE_TYPE),
         "deps": attr.label_list(
             aspects = [closure_js_aspect],
-            providers = ["closure_js_library"],
+            providers = [ClosureJsLibraryInfo],
         ),
         "outputs": attr.output_list(),
         "globals": attr.label(allow_single_file = True),
diff --git a/closure/testing/phantomjs_test.bzl b/closure/testing/phantomjs_test.bzl
index c6739eb1cd..7ff4332a74 100644
--- a/closure/testing/phantomjs_test.bzl
+++ b/closure/testing/phantomjs_test.bzl
@@ -19,6 +19,8 @@
 
 load(
     "//closure/private:defs.bzl",
+    "ClosureJsBinaryInfo",
+    "ClosureJsLibraryInfo",
     "HTML_FILE_TYPE",
     "collect_runfiles",
     "long_path",
@@ -31,12 +33,12 @@ def _impl(ctx):
     files = [ctx.outputs.executable]
     srcs = []
     direct_srcs = []
-    deps = unfurl(ctx.attr.deps, provider = "closure_js_library")
+    deps = unfurl(ctx.attr.deps, provider = ClosureJsLibraryInfo).exports
     for dep in deps:
-        if hasattr(dep, "closure_js_binary"):
-            direct_srcs += [dep.closure_js_binary.bin]
+        if ClosureJsBinaryInfo in dep:
+            direct_srcs += [dep[ClosureJsBinaryInfo].bin]
         else:
-            srcs += [dep.closure_js_library.srcs]
+            srcs += [dep[ClosureJsLibraryInfo].srcs]
     srcs = depset(direct_srcs, transitive = srcs)
     deps.append(ctx.attr.runner)
 
@@ -45,16 +47,16 @@ def _impl(ctx):
     ]
     if ctx.attr.debug:
         args += ["--debug=true"]
-    args += [ctx.attr.harness.closure_js_binary.bin.short_path]
+    args += [ctx.attr.harness[ClosureJsBinaryInfo].bin.short_path]
     args += [ctx.file.html.short_path]
     args += [long_path(ctx, src) for src in srcs.to_list()]
-    args += [long_path(ctx, src) for src in ctx.attr.runner.closure_js_library.srcs.to_list()]
+    args += [long_path(ctx, src) for src in ctx.attr.runner[ClosureJsLibraryInfo].srcs.to_list()]
     ctx.actions.write(
         is_executable = True,
         output = ctx.outputs.executable,
         content = " \\\n  ".join(args),
     )
-    return struct(
+    return DefaultInfo(
         files = depset(files),
         runfiles = ctx.runfiles(
             files = files + ctx.attr.data + [ctx.file.html],
@@ -74,10 +76,10 @@ phantomjs_test = rule(
     test = True,
     implementation = _impl,
     attrs = {
-        "deps": attr.label_list(providers = ["closure_js_library"]),
-        "runner": attr.label(providers = ["closure_js_library"]),
+        "deps": attr.label_list(providers = [ClosureJsLibraryInfo]),
+        "runner": attr.label(providers = [ClosureJsLibraryInfo]),
         "harness": attr.label(
-            providers = ["closure_js_binary"],
+            providers = [ClosureJsBinaryInfo],
             default = Label("//closure/testing:phantomjs_harness_bin"),
         ),
         "html": attr.label(
diff --git a/closure/webfiles/web_library.bzl b/closure/webfiles/web_library.bzl
index 9141daa898..58f890876d 100644
--- a/closure/webfiles/web_library.bzl
+++ b/closure/webfiles/web_library.bzl
@@ -16,6 +16,7 @@
 
 load(
     "//closure/private:defs.bzl",
+    "WebFilesInfo",
     "create_argfile",
     "difference",
     "long_path",
@@ -39,12 +40,12 @@ def _web_library(ctx):
         fail("when \"*\" is suppressed no other items should be present")
 
     # process what came before
-    deps = unfurl(ctx.attr.deps, provider = "webfiles")
+    deps = unfurl(ctx.attr.deps, provider = WebFilesInfo).exports
     webpaths = []
     manifests = []
     for dep in deps:
-        webpaths.append(dep.webfiles.webpaths)
-        manifests += [dep.webfiles.manifests]
+        webpaths.append(dep[WebFilesInfo].webpaths)
+        manifests += [dep[WebFilesInfo].manifests]
 
     # process what comes now
     new_webpaths = []
@@ -102,13 +103,13 @@ def _web_library(ctx):
         args.append(category)
     inputs.extend(ctx.files.srcs)
     for dep in deps:
-        inputs.append(dep.webfiles.dummy)
+        inputs.append(dep[WebFilesInfo].dummy)
         for f in dep.files.to_list():
             inputs.append(f)
-        direct_manifests += [dep.webfiles.manifest]
-        inputs.append(dep.webfiles.manifest)
+        direct_manifests += [dep[WebFilesInfo].manifest]
+        inputs.append(dep[WebFilesInfo].manifest)
         args.append("--direct_dep")
-        args.append(dep.webfiles.manifest.path)
+        args.append(dep[WebFilesInfo].manifest.path)
     for man in difference(manifests, depset(direct_manifests)):
         inputs.append(man)
         args.append("--transitive_dep")
@@ -151,25 +152,27 @@ def _web_library(ctx):
                      [dep.data_runfiles.files for dep in deps],
     )
 
-    return struct(
-        files = depset([ctx.outputs.executable, ctx.outputs.dummy]),
-        exports = unfurl(ctx.attr.exports),
-        webfiles = struct(
+    return [
+        DefaultInfo(
+            files = depset([ctx.outputs.executable, ctx.outputs.dummy]),
+            runfiles = ctx.runfiles(
+                files = ctx.files.srcs + ctx.files.data + [
+                    manifest,
+                    params_file,
+                    ctx.outputs.executable,
+                    ctx.outputs.dummy,
+                ],
+                transitive_files = transitive_runfiles,
+            ),
+        ),
+        unfurl(ctx.attr.exports),
+        WebFilesInfo(
             manifest = manifest,
             manifests = manifests,
             webpaths = depset(transitive = webpaths),
             dummy = ctx.outputs.dummy,
         ),
-        runfiles = ctx.runfiles(
-            files = ctx.files.srcs + ctx.files.data + [
-                manifest,
-                params_file,
-                ctx.outputs.executable,
-                ctx.outputs.dummy,
-            ],
-            transitive_files = transitive_runfiles,
-        ),
-    )
+    ]
 
 def _fail(ctx, message):
     if ctx.attr.suppress == ["*"]:
@@ -212,7 +215,7 @@ web_library = rule(
         "host": attr.string(default = "0.0.0.0"),
         "port": attr.string(default = "6006"),
         "srcs": attr.label_list(allow_files = True),
-        "deps": attr.label_list(providers = ["webfiles"]),
+        "deps": attr.label_list(providers = [WebFilesInfo]),
         "use_full_path": attr.bool(default = False),
         "exports": attr.label_list(),
         "data": attr.label_list(allow_files = True),