diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java
index 1ff392b..578af77 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/cpp/BazelCcModule.java
@@ -89,7 +89,6 @@
       Object textualHeaders,
       Object additionalExportedHeaders,
       Sequence<?> includes, // <String> expected
-      Object looseIncludes,
       Sequence<?> quoteIncludes, // <String> expected
       Sequence<?> systemIncludes, // <String> expected
       Sequence<?> frameworkIncludes, // <String> expected
@@ -99,7 +98,6 @@
       String stripIncludePrefix,
       Sequence<?> userCompileFlags, // <String> expected
       Sequence<?> ccCompilationContexts, // <CcCompilationContext> expected
-      Object implementationCcCompilationContexts,
       String name,
       boolean disallowPicOutputs,
       boolean disallowNopicOutputs,
@@ -114,7 +112,6 @@
       Object language,
       Object purpose,
       Object grepIncludes,
-      Object coptsFilter,
       StarlarkThread thread)
       throws EvalException, InterruptedException {
     return compile(
@@ -127,7 +124,6 @@
         textualHeaders,
         additionalExportedHeaders,
         includes,
-        looseIncludes,
         quoteIncludes,
         systemIncludes,
         frameworkIncludes,
@@ -137,7 +133,6 @@
         stripIncludePrefix,
         userCompileFlags,
         ccCompilationContexts,
-        implementationCcCompilationContexts,
         name,
         disallowPicOutputs,
         disallowNopicOutputs,
@@ -154,7 +149,6 @@
         variablesExtension,
         language,
         purpose,
-        coptsFilter,
         thread);
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
index 5f547b8..a8917e1 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcCompilationHelper.java
@@ -584,7 +584,7 @@
   }
 
   /** Sets a pattern that is used to filter copts; set to {@code null} for no filtering. */
-  public void setCoptsFilter(CoptsFilter coptsFilter) {
+  private void setCoptsFilter(CoptsFilter coptsFilter) {
     this.coptsFilter = Preconditions.checkNotNull(coptsFilter);
   }
 
@@ -637,8 +637,8 @@
    * Sets the given directories to by loose include directories that are only allowed to be
    * referenced when headers checking is {@link HeadersCheckingMode#LOOSE}.
    */
-  public void setLooseIncludeDirs(Set<PathFragment> looseIncludeDirs) {
-    this.looseIncludeDirs = Preconditions.checkNotNull(looseIncludeDirs);
+  private void setLooseIncludeDirs(Set<PathFragment> looseIncludeDirs) {
+    this.looseIncludeDirs = looseIncludeDirs;
   }
 
   /**
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
index 475faa3..be47ae9 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
@@ -46,7 +46,6 @@
 import com.google.devtools.build.lib.packages.StarlarkInfo;
 import com.google.devtools.build.lib.packages.TargetUtils;
 import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
-import com.google.devtools.build.lib.rules.cpp.CcCommon.CoptsFilter;
 import com.google.devtools.build.lib.rules.cpp.CcCompilationHelper.CompilationInfo;
 import com.google.devtools.build.lib.rules.cpp.CcCompilationHelper.SourceCategory;
 import com.google.devtools.build.lib.rules.cpp.CcLinkingContext.LinkOptions;
@@ -793,24 +792,6 @@
         .build();
   }
 
-  @StarlarkMethod(
-      name = "merge_linking_contexts",
-      documented = false,
-      parameters = {
-        @Param(
-            name = "linking_contexts",
-            documented = false,
-            positional = false,
-            named = true,
-            defaultValue = "[]"),
-      })
-  public CcLinkingContext mergeLinkingContexts(
-      Sequence<?> linkingContexts) // <CcLinkingContext> expected
-      throws EvalException {
-    return CcLinkingContext.merge(
-        Sequence.cast(linkingContexts, CcLinkingContext.class, "linking_contexts"));
-  }
-
   private static NestedSet<Artifact> toNestedSetOfArtifacts(Object obj, String fieldName)
       throws EvalException {
     if (obj == Starlark.UNBOUND) {
@@ -903,14 +884,11 @@
       // make sense here since LinkerInput takes a list of flags. For storing user_link_flags
       // without flattening they would have to be wrapped around a LinkerInput for which we keep
       // a depset that isn't flattened till the end.
-      ImmutableList<String> userLinkFlagsFlattened =
-          Depset.noneableCast(userLinkFlagsObject, String.class, "user_link_flags").toList();
-      if (!userLinkFlagsFlattened.isEmpty()) {
-        LinkOptions options =
-            LinkOptions.of(
-                userLinkFlagsFlattened, BazelStarlarkContext.from(thread).getSymbolGenerator());
-        optionsBuilder.add(options);
-      }
+      LinkOptions options =
+          LinkOptions.of(
+              Depset.noneableCast(userLinkFlagsObject, String.class, "user_link_flags").toList(),
+              BazelStarlarkContext.from(thread).getSymbolGenerator());
+      optionsBuilder.add(options);
     } else if (userLinkFlagsObject instanceof Sequence) {
       ImmutableList<Object> options =
           Sequence.cast(userLinkFlagsObject, Object.class, "user_link_flags[]").getImmutableList();
@@ -1813,16 +1791,8 @@
         convertFromNoneable(starlarkFeatureConfiguration, null);
     Label label = getCallerLabel(actions, name);
     FdoContext fdoContext = ccToolchainProvider.getFdoContext();
-    LinkTargetType staticLinkTargetType = null;
-    if (language == Language.CPP) {
-      if (alwayslink) {
-        staticLinkTargetType = LinkTargetType.ALWAYS_LINK_STATIC_LIBRARY;
-      } else {
-        staticLinkTargetType = LinkTargetType.STATIC_LIBRARY;
-      }
-    } else {
-      staticLinkTargetType = LinkTargetType.OBJC_ARCHIVE;
-    }
+    LinkTargetType staticLinkTargetType =
+        (language == Language.CPP) ? LinkTargetType.STATIC_LIBRARY : LinkTargetType.OBJC_ARCHIVE;
     CcLinkingHelper helper =
         new CcLinkingHelper(
                 actions.getActionConstructionContext().getRuleErrorConsumer(),
@@ -1853,7 +1823,6 @@
                         .isEnabled(CppRuleClasses.TARGETS_WINDOWS))
             .setStaticLinkType(staticLinkTargetType)
             .setDynamicLinkType(LinkTargetType.NODEPS_DYNAMIC_LIBRARY)
-            .emitInterfaceSharedLibraries(true)
             .addLinkopts(Sequence.cast(userLinkFlags, String.class, "user_link_flags"));
     if (!asDict(variablesExtension).isEmpty()) {
       helper.addVariableExtension(new UserVariablesExtension(asDict(variablesExtension)));
@@ -1979,7 +1948,6 @@
       Object textualHeadersStarlarkObject,
       Object additionalExportedHeadersObject,
       Sequence<?> includes, // <String> expected
-      Object starlarkIncludes,
       Sequence<?> quoteIncludes, // <String> expected
       Sequence<?> systemIncludes, // <String> expected
       Sequence<?> frameworkIncludes, // <String> expected
@@ -1989,7 +1957,6 @@
       String stripIncludePrefix,
       Sequence<?> userCompileFlags, // <String> expected
       Sequence<?> ccCompilationContexts, // <CcCompilationContext> expected
-      Object implementationCcCompilationContextsObject,
       String name,
       boolean disallowPicOutputs,
       boolean disallowNopicOutputs,
@@ -2005,7 +1972,6 @@
       Object variablesExtension,
       Object languageObject,
       Object purposeObject,
-      Object coptsFilterObject,
       StarlarkThread thread)
       throws EvalException, InterruptedException {
     if (checkObjectsBound(
@@ -2016,10 +1982,7 @@
         doNotGenerateModuleMapObject,
         codeCoverageEnabledObject,
         purposeObject,
-        hdrsCheckingModeObject,
-        implementationCcCompilationContextsObject,
-        coptsFilterObject,
-        starlarkIncludes)) {
+        hdrsCheckingModeObject)) {
       CcModule.checkPrivateStarlarkificationAllowlist(thread);
     }
 
@@ -2027,13 +1990,10 @@
     CcToolchainProvider ccToolchainProvider =
         convertFromNoneable(starlarkCcToolchainProvider, null);
 
-    ImmutableList<String> looseIncludes = asClassImmutableList(starlarkIncludes);
     CppModuleMap moduleMap = convertFromNoneable(moduleMapNoneable, /* defaultValue= */ null);
     ImmutableList<CppModuleMap> additionalModuleMaps =
         asClassImmutableList(additionalModuleMapsNoneable);
 
-    CoptsFilter coptsFilter = convertFromNoneable(coptsFilterObject, /* defaultValue= */ null);
-
     Object textualHeadersObject =
         asClassImmutableListOrNestedSet(
             textualHeadersStarlarkObject, Artifact.class, "textual_headers");
@@ -2062,20 +2022,28 @@
                     ccToolchainProvider)
                 .toString());
     String purpose = convertFromNoneable(purposeObject, null);
-    ImmutableList<CcCompilationContext> implementationContexts =
-        asClassImmutableList(implementationCcCompilationContextsObject);
 
-    boolean tuple =
-        checkAllSourcesContainTuplesOrNoneOfThem(
-            ImmutableList.of(sourcesUnchecked, privateHeadersUnchecked, publicHeadersUnchecked));
-    if (tuple) {
-      CcModule.checkPrivateStarlarkificationAllowlist(thread);
-    }
+    List<Artifact> sources = Sequence.cast(sourcesUnchecked, Artifact.class, "srcs");
+    List<Artifact> publicHeaders =
+        Sequence.cast(publicHeadersUnchecked, Artifact.class, "public_hdrs");
+    List<Artifact> privateHeaders =
+        Sequence.cast(privateHeadersUnchecked, Artifact.class, "private_hdrs");
 
     FeatureConfigurationForStarlark featureConfiguration =
         convertFromNoneable(starlarkFeatureConfiguration, null);
     Label label = getCallerLabel(actions, name);
     FdoContext fdoContext = ccToolchainProvider.getFdoContext();
+    validateExtensions(
+        "srcs",
+        sources,
+        CppFileTypes.ALL_C_CLASS_SOURCE.including(
+            CppFileTypes.ASSEMBLER_WITH_C_PREPROCESSOR, CppFileTypes.ASSEMBLER),
+        FileTypeSet.of(
+            CppFileTypes.CPP_SOURCE,
+            CppFileTypes.C_SOURCE,
+            CppFileTypes.ASSEMBLER_WITH_C_PREPROCESSOR,
+            CppFileTypes.ASSEMBLER),
+        /* allowAnyTreeArtifacts= */ true);
 
     if (disallowNopicOutputs && disallowPicOutputs) {
       throw Starlark.errorf("Either PIC or no PIC actions have to be created.");
@@ -2087,83 +2055,62 @@
     BuildConfiguration configuration = actions.getActionConstructionContext().getConfiguration();
     CcCompilationHelper helper =
         new CcCompilationHelper(
-            actions.asActionRegistry(actions),
-            actions.getActionConstructionContext(),
-            label,
-            grepIncludes,
-            getSemantics(language),
-            featureConfiguration.getFeatureConfiguration(),
-            sourceCategory,
-            ccToolchainProvider,
-            fdoContext,
-            actions.getActionConstructionContext().getConfiguration(),
-            TargetUtils.getExecutionInfo(
-                actions.getRuleContext().getRule(),
-                actions.getRuleContext().isAllowTagsPropagation()),
-            /* shouldProcessHeaders= */ ccToolchainProvider.shouldProcessHeaders(
+                actions.asActionRegistry(actions),
+                actions.getActionConstructionContext(),
+                label,
+                grepIncludes,
+                getSemantics(language),
                 featureConfiguration.getFeatureConfiguration(),
-                configuration.getFragment(CppConfiguration.class)));
-    if (tuple) {
-      ImmutableList<Pair<Artifact, Label>> sources = convertSequenceTupleToPair(sourcesUnchecked);
-      ImmutableList<Pair<Artifact, Label>> publicHeaders =
-          convertSequenceTupleToPair(publicHeadersUnchecked);
-      ImmutableList<Pair<Artifact, Label>> privateHeaders =
-          convertSequenceTupleToPair(privateHeadersUnchecked);
-      helper.addPublicHeaders(publicHeaders).addPrivateHeaders(privateHeaders).addSources(sources);
-    } else {
-      List<Artifact> sources = Sequence.cast(sourcesUnchecked, Artifact.class, "srcs");
-      List<Artifact> publicHeaders =
-          Sequence.cast(publicHeadersUnchecked, Artifact.class, "public_hdrs");
-      List<Artifact> privateHeaders =
-          Sequence.cast(privateHeadersUnchecked, Artifact.class, "private_hdrs");
-      helper.addPublicHeaders(publicHeaders).addPrivateHeaders(privateHeaders).addSources(sources);
-    }
-
-    helper
-        .addCcCompilationContexts(
-            Sequence.cast(
-                ccCompilationContexts, CcCompilationContext.class, "compilation_contexts"))
-        .addImplementationDepsCcCompilationContexts(implementationContexts)
-        .addIncludeDirs(
-            Sequence.cast(includes, String.class, "includes").stream()
-                .map(PathFragment::create)
-                .collect(ImmutableList.toImmutableList()))
-        .addQuoteIncludeDirs(
-            Sequence.cast(quoteIncludes, String.class, "quote_includes").stream()
-                .map(PathFragment::create)
-                .collect(ImmutableList.toImmutableList()))
-        .addSystemIncludeDirs(
-            Sequence.cast(systemIncludes, String.class, "system_includes").stream()
-                .map(PathFragment::create)
-                .collect(ImmutableList.toImmutableList()))
-        .addFrameworkIncludeDirs(
-            Sequence.cast(frameworkIncludes, String.class, "framework_includes").stream()
-                .map(PathFragment::create)
-                .collect(ImmutableList.toImmutableList()))
-        .addDefines(Sequence.cast(defines, String.class, "defines"))
-        .addNonTransitiveDefines(Sequence.cast(localDefines, String.class, "local_defines"))
-        .setCopts(
-            ImmutableList.copyOf(
-                Sequence.cast(userCompileFlags, String.class, "user_compile_flags")))
-        .addAdditionalCompilationInputs(headersForClifDoNotUseThisParam)
-        .addAdditionalCompilationInputs(
-            Sequence.cast(additionalInputs, Artifact.class, "additional_inputs"))
-        .addAditionalIncludeScanningRoots(headersForClifDoNotUseThisParam)
-        .setPurpose(common.getPurpose(getSemantics(language)))
-        .addAdditionalExportedHeaders(
-            additionalExportedHeaders.stream()
-                .map(PathFragment::create)
-                .collect(ImmutableList.toImmutableList()))
-        .setPropagateModuleMapToCompileAction(propagateModuleMapToCompileAction)
-        .setCodeCoverageEnabled(codeCoverageEnabled)
-        .setHeadersCheckingMode(HeadersCheckingMode.valueOf(Ascii.toUpperCase(hdrsCheckingMode)));
-
-    ImmutableList<PathFragment> looseIncludeDirs =
-        looseIncludes.stream().map(PathFragment::create).collect(ImmutableList.toImmutableList());
-    if (!looseIncludeDirs.isEmpty()) {
-      helper.setLooseIncludeDirs(ImmutableSet.copyOf(looseIncludeDirs));
-    }
-
+                sourceCategory,
+                ccToolchainProvider,
+                fdoContext,
+                actions.getActionConstructionContext().getConfiguration(),
+                TargetUtils.getExecutionInfo(
+                    actions.getRuleContext().getRule(),
+                    actions.getRuleContext().isAllowTagsPropagation()),
+                /* shouldProcessHeaders= */ ccToolchainProvider.shouldProcessHeaders(
+                    featureConfiguration.getFeatureConfiguration(),
+                    configuration.getFragment(CppConfiguration.class)))
+            .addPublicHeaders(publicHeaders)
+            .addPrivateHeaders(privateHeaders)
+            .addSources(sources)
+            .addCcCompilationContexts(
+                Sequence.cast(
+                    ccCompilationContexts, CcCompilationContext.class, "compilation_contexts"))
+            .addIncludeDirs(
+                Sequence.cast(includes, String.class, "includes").stream()
+                    .map(PathFragment::create)
+                    .collect(ImmutableList.toImmutableList()))
+            .addQuoteIncludeDirs(
+                Sequence.cast(quoteIncludes, String.class, "quote_includes").stream()
+                    .map(PathFragment::create)
+                    .collect(ImmutableList.toImmutableList()))
+            .addSystemIncludeDirs(
+                Sequence.cast(systemIncludes, String.class, "system_includes").stream()
+                    .map(PathFragment::create)
+                    .collect(ImmutableList.toImmutableList()))
+            .addFrameworkIncludeDirs(
+                Sequence.cast(frameworkIncludes, String.class, "framework_includes").stream()
+                    .map(PathFragment::create)
+                    .collect(ImmutableList.toImmutableList()))
+            .addDefines(Sequence.cast(defines, String.class, "defines"))
+            .addNonTransitiveDefines(Sequence.cast(localDefines, String.class, "local_defines"))
+            .setCopts(
+                ImmutableList.copyOf(
+                    Sequence.cast(userCompileFlags, String.class, "user_compile_flags")))
+            .addAdditionalCompilationInputs(headersForClifDoNotUseThisParam)
+            .addAdditionalCompilationInputs(
+                Sequence.cast(additionalInputs, Artifact.class, "additional_inputs"))
+            .addAditionalIncludeScanningRoots(headersForClifDoNotUseThisParam)
+            .setPurpose(common.getPurpose(getSemantics(language)))
+            .addAdditionalExportedHeaders(
+                additionalExportedHeaders.stream()
+                    .map(PathFragment::create)
+                    .collect(ImmutableList.toImmutableList()))
+            .setPropagateModuleMapToCompileAction(propagateModuleMapToCompileAction)
+            .setCodeCoverageEnabled(codeCoverageEnabled)
+            .setHeadersCheckingMode(
+                HeadersCheckingMode.valueOf(Ascii.toUpperCase(hdrsCheckingMode)));
     if (textualHeadersObject instanceof NestedSet) {
       helper.addPublicTextualHeaders((NestedSet<Artifact>) textualHeadersObject);
     } else {
@@ -2175,9 +2122,6 @@
     if (moduleMap != null) {
       helper.setCppModuleMap(moduleMap);
     }
-    if (coptsFilter != null) {
-      helper.setCoptsFilter(coptsFilter);
-    }
     for (CppModuleMap additionalModuleMap : additionalModuleMaps) {
       helper.registerAdditionalModuleMap(additionalModuleMap);
     }
@@ -2210,29 +2154,6 @@
     }
   }
 
-  private boolean checkAllSourcesContainTuplesOrNoneOfThem(ImmutableList<Sequence<?>> files)
-      throws EvalException {
-    boolean nonTuple = false;
-    boolean tuple = false;
-    for (Sequence<?> sequence : files) {
-      if (!sequence.isEmpty()) {
-        if (sequence.get(0) instanceof Tuple) {
-          tuple = true;
-        } else if (sequence.get(0) instanceof Artifact) {
-          nonTuple = true;
-        } else {
-          throw new EvalException(
-              "srcs, private_hdrs and public_hdrs must all be Tuples<File, Label> or File");
-        }
-        if (tuple && nonTuple) {
-          throw new EvalException(
-              "srcs, private_hdrs and public_hdrs must all be Tuples<File, Label> or File");
-        }
-      }
-    }
-    return tuple;
-  }
-
   protected CcLinkingOutputs link(
       StarlarkActionFactory actions,
       FeatureConfigurationForStarlark starlarkFeatureConfiguration,
@@ -2500,11 +2421,4 @@
                 outputReplacement,
                 getSemantics()));
   }
-
-  private ImmutableList<Pair<Artifact, Label>> convertSequenceTupleToPair(Sequence<?> sequenceTuple)
-      throws EvalException {
-    return Sequence.cast(sequenceTuple, Tuple.class, "files").stream()
-        .map(p -> Pair.of((Artifact) p.get(0), (Label) p.get(1)))
-        .collect(ImmutableList.toImmutableList());
-  }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/starlarkbuildapi/cpp/BazelCcModuleApi.java b/src/main/java/com/google/devtools/build/lib/starlarkbuildapi/cpp/BazelCcModuleApi.java
index 81403da..3cee927 100644
--- a/src/main/java/com/google/devtools/build/lib/starlarkbuildapi/cpp/BazelCcModuleApi.java
+++ b/src/main/java/com/google/devtools/build/lib/starlarkbuildapi/cpp/BazelCcModuleApi.java
@@ -143,13 +143,6 @@
             named = true,
             defaultValue = "[]"),
         @Param(
-            name = "loose_includes",
-            documented = false,
-            positional = false,
-            named = true,
-            defaultValue = "unbound",
-            allowedTypes = {@ParamType(type = Sequence.class), @ParamType(type = NoneType.class)}),
-        @Param(
             name = "quote_includes",
             doc =
                 "Search paths for header files referenced by quotes, "
@@ -230,16 +223,6 @@
             named = true,
             defaultValue = "[]"),
         @Param(
-            name = "implementation_compilation_contexts",
-            documented = false,
-            positional = false,
-            defaultValue = "unbound",
-            allowedTypes = {
-              @ParamType(type = Sequence.class, generic1 = CcCompilationContextApi.class),
-              @ParamType(type = NoneType.class)
-            },
-            named = true),
-        @Param(
             name = "name",
             doc =
                 "This is used for naming the output artifacts of actions created by this "
@@ -338,24 +321,17 @@
               @ParamType(type = FileApi.class),
               @ParamType(type = NoneType.class),
             }),
-        @Param(
-            name = "copts_filter",
-            documented = false,
-            positional = false,
-            named = true,
-            defaultValue = "unbound"),
       })
   Tuple compile(
       StarlarkActionFactoryT starlarkActionFactoryApi,
       FeatureConfigurationT starlarkFeatureConfiguration,
       CcToolchainProviderT starlarkCcToolchainProvider,
-      Sequence<?> sources, // <FileT> or Tuple<FileT,Label> expected
-      Sequence<?> publicHeaders, // <FileT> or Tuple<FileT,Label> expected
-      Sequence<?> privateHeaders, // <FileT> or Tuple<FileT,Label> expected
+      Sequence<?> sources, // <FileT> expected
+      Sequence<?> publicHeaders, // <FileT> expected
+      Sequence<?> privateHeaders, // <FileT> expected
       Object textualHeaders,
       Object additionalExportedHeaders,
       Sequence<?> includes, // <String> expected
-      Object starlarkLooseIncludes,
       Sequence<?> quoteIncludes, // <String> expected
       Sequence<?> systemIncludes, // <String> expected
       Sequence<?> frameworkIncludes, // <String> expected
@@ -365,7 +341,6 @@
       String stripIncludePrefix,
       Sequence<?> userCompileFlags, // <String> expected
       Sequence<?> ccCompilationContexts, // <CompilationContextT> expected
-      Object implementationCcCompilationContexts,
       String name,
       boolean disallowPicOutputs,
       boolean disallowNopicOutputs,
@@ -380,7 +355,6 @@
       Object language,
       Object purpose,
       Object grepIncludes,
-      Object coptsFilter,
       StarlarkThread thread)
       throws EvalException, InterruptedException;
 
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/StarlarkCcCommonTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/StarlarkCcCommonTest.java
index 6486d83..09bc43f 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/StarlarkCcCommonTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/StarlarkCcCommonTest.java
@@ -5465,7 +5465,7 @@
     createFilesForTestingCompilation(
         scratch, "third_party/tools/build_defs/foo", "include_prefix='prefix'");
     scratch.file(
-        "third_party/bar/BUILD",
+        "bar/BUILD",
         "load('//third_party/tools/build_defs/foo:extension.bzl', 'cc_starlark_library')",
         "cc_starlark_library(",
         "    name = 'starlark_lib',",
@@ -5473,11 +5473,11 @@
         "    public_hdrs = ['starlark_lib.h'],",
         "    private_hdrs = ['private_starlark_lib.h'],",
         ")");
-    ConfiguredTarget target = getConfiguredTarget("//third_party/bar:starlark_lib");
+    ConfiguredTarget target = getConfiguredTarget("//bar:starlark_lib");
     assertThat(target).isNotNull();
     CcInfo ccInfo = target.get(CcInfo.PROVIDER);
     assertThat(artifactsToStrings(ccInfo.getCcCompilationContext().getDirectPublicHdrs()))
-        .contains("bin third_party/bar/_virtual_includes/starlark_lib/prefix/starlark_lib.h");
+        .contains("bin bar/_virtual_includes/starlark_lib/prefix/starlark_lib.h");
   }
 
   @Test
@@ -5485,7 +5485,7 @@
     createFilesForTestingCompilation(
         scratch, "third_party/tools/build_defs/foo", "strip_include_prefix='v1'");
     scratch.file(
-        "third_party/bar/BUILD",
+        "bar/BUILD",
         "load('//third_party/tools/build_defs/foo:extension.bzl', 'cc_starlark_library')",
         "cc_starlark_library(",
         "    name = 'starlark_lib',",
@@ -5493,11 +5493,11 @@
         "    public_hdrs = ['v1/starlark_lib.h'],",
         "    private_hdrs = ['v1/private_starlark_lib.h'],",
         ")");
-    ConfiguredTarget target = getConfiguredTarget("//third_party/bar:starlark_lib");
+    ConfiguredTarget target = getConfiguredTarget("//bar:starlark_lib");
     assertThat(target).isNotNull();
     CcInfo ccInfo = target.get(CcInfo.PROVIDER);
     assertThat(artifactsToStrings(ccInfo.getCcCompilationContext().getDirectPublicHdrs()))
-        .contains("bin third_party/bar/_virtual_includes/starlark_lib/starlark_lib.h");
+        .contains("bin bar/_virtual_includes/starlark_lib/starlark_lib.h");
   }
 
   @Test
@@ -5507,7 +5507,7 @@
         "third_party/tools/build_defs/foo",
         "strip_include_prefix='v1', include_prefix='prefix'");
     scratch.file(
-        "third_party/bar/BUILD",
+        "bar/BUILD",
         "load('//third_party/tools/build_defs/foo:extension.bzl', 'cc_starlark_library')",
         "cc_starlark_library(",
         "    name = 'starlark_lib',",
@@ -5515,11 +5515,11 @@
         "    public_hdrs = ['v1/starlark_lib.h'],",
         "    private_hdrs = ['v1/private_starlark_lib.h'],",
         ")");
-    ConfiguredTarget target = getConfiguredTarget("//third_party/bar:starlark_lib");
+    ConfiguredTarget target = getConfiguredTarget("//bar:starlark_lib");
     assertThat(target).isNotNull();
     CcInfo ccInfo = target.get(CcInfo.PROVIDER);
     assertThat(artifactsToStrings(ccInfo.getCcCompilationContext().getDirectPublicHdrs()))
-        .contains("bin third_party/bar/_virtual_includes/starlark_lib/prefix/starlark_lib.h");
+        .contains("bin bar/_virtual_includes/starlark_lib/prefix/starlark_lib.h");
   }
 
   @Test
@@ -5669,6 +5669,27 @@
     doTestTreeAtrifactInSrcsAndHdrs("public_hdrs");
   }
 
+  @Test
+  public void testWrongSrcsExtensionGivesError() throws Exception {
+    doTestWrongExtensionOfSrcsAndHdrs("srcs");
+  }
+
+  @Test
+  public void testWrongSrcExtensionGivesError() throws Exception {
+    createFiles(scratch, "tools/build_defs/foo");
+
+    scratch.file(
+        "bar/BUILD",
+        "load('//tools/build_defs/foo:extension.bzl', 'cc_starlark_library')",
+        "cc_starlark_library(",
+        "    name = 'starlark_lib',",
+        "    srcs = ['starlark_lib.qweqwe'],",
+        ")");
+    reporter.removeHandler(failFastHandler);
+    getConfiguredTarget("//bar:starlark_lib");
+    assertContainsEvent("The list of possible extensions for 'srcs'");
+  }
+
   private static void createFilesForTestingCompilation(
       Scratch scratch, String bzlFilePath, String compileProviderLines) throws Exception {
     createFiles(scratch, bzlFilePath, compileProviderLines, "");
@@ -6146,6 +6167,21 @@
         ")");
   }
 
+  private void doTestWrongExtensionOfSrcsAndHdrs(String attrName) throws Exception {
+    createFiles(scratch, "tools/build_defs/foo");
+    scratch.file(
+        "bar/BUILD",
+        "load('//tools/build_defs/foo:extension.bzl', 'cc_starlark_library')",
+        "cc_starlark_library(",
+        "    name = 'starlark_lib',",
+        "    " + attrName + " = ['starlark_lib.cannotpossiblybevalid'],",
+        ")");
+    reporter.removeHandler(failFastHandler);
+    getConfiguredTarget("//bar:starlark_lib");
+    assertContainsEvent(
+        "has wrong extension. The list of possible extensions for '" + attrName + "'");
+  }
+
   private void doTestPossibleExtensionsOfSrcsAndHdrs(String attrName, List<String> extensions)
       throws Exception {
     createFiles(scratch, "tools/build_defs/foo");
