diff --git a/WORKSPACE b/WORKSPACE index 2b2cf1bc230..dc4274ba730 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -329,10 +329,10 @@ http_archive( http_archive( name = "rules_java", + sha256 = "7b0d9ba216c821ee8697dedc0f9d0a705959ace462a3885fe9ba0347ba950111", urls = [ "https://github.com/bazelbuild/rules_java/releases/download/6.5.1/rules_java-6.5.1.tar.gz", ], - sha256 = "7b0d9ba216c821ee8697dedc0f9d0a705959ace462a3885fe9ba0347ba950111", ) # LICENSE: Common Public License 1.0 diff --git a/aswb/sdkcompat/as223/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java b/aswb/sdkcompat/as223/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java new file mode 100644 index 00000000000..21516076cc2 --- /dev/null +++ b/aswb/sdkcompat/as223/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java @@ -0,0 +1,66 @@ +/* + * Copyright 2016 The Bazel Authors. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.google.idea.blaze.android.resources; + +import com.android.tools.idea.projectsystem.LightResourceClassService; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import com.google.idea.blaze.base.sync.data.BlazeDataStorage; +import com.google.idea.common.experiments.FeatureRolloutExperiment; +import com.intellij.openapi.module.Module; +import com.intellij.psi.PsiClass; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +/** Implementation of {@link LightResourceClassService} set up at Blaze sync time. */ +public abstract class BlazeLightResourceClassServiceBase implements LightResourceClassService { + + @VisibleForTesting + public static final FeatureRolloutExperiment workspaceResourcesFeature = + new FeatureRolloutExperiment("aswb.workspace.light.class.enabled"); + + Map rClasses = Maps.newHashMap(); + Map rClassesByModule = Maps.newHashMap(); + final Set allRClasses = Sets.newHashSet(); + + @Override + public Collection getLightRClassesAccessibleFromModule( + Module module, boolean includeTest) { + if (workspaceResourcesFeature.isEnabled() + && module.getName().equals(BlazeDataStorage.WORKSPACE_MODULE_NAME)) { + // Returns all the packages in resource modules, and all the workspace packages that + // have previously been asked for. All `res/` directories in our project should belong to a + // resource module. For java sources, IntelliJ will ask for explicit resource package by + // calling `getLightRClasses` at which point we can create the package. This is not completely + // correct and the autocomplete will be slightly off when initial `R` is typed in the editor, + // but this workaround is being used to mitigate issues (b/136685602) while resources + // are re-worked. + return allRClasses; + } else { + return rClasses.values(); + } + } + + @Override + public Collection getLightRClassesDefinedByModule( + Module module, boolean includeTestClasses) { + BlazeRClass rClass = rClassesByModule.get(module); + return rClass == null ? ImmutableSet.of() : ImmutableSet.of(rClass); + } +} diff --git a/aswb/sdkcompat/as231/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java b/aswb/sdkcompat/as231/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java new file mode 100644 index 00000000000..21516076cc2 --- /dev/null +++ b/aswb/sdkcompat/as231/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java @@ -0,0 +1,66 @@ +/* + * Copyright 2016 The Bazel Authors. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.google.idea.blaze.android.resources; + +import com.android.tools.idea.projectsystem.LightResourceClassService; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import com.google.idea.blaze.base.sync.data.BlazeDataStorage; +import com.google.idea.common.experiments.FeatureRolloutExperiment; +import com.intellij.openapi.module.Module; +import com.intellij.psi.PsiClass; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +/** Implementation of {@link LightResourceClassService} set up at Blaze sync time. */ +public abstract class BlazeLightResourceClassServiceBase implements LightResourceClassService { + + @VisibleForTesting + public static final FeatureRolloutExperiment workspaceResourcesFeature = + new FeatureRolloutExperiment("aswb.workspace.light.class.enabled"); + + Map rClasses = Maps.newHashMap(); + Map rClassesByModule = Maps.newHashMap(); + final Set allRClasses = Sets.newHashSet(); + + @Override + public Collection getLightRClassesAccessibleFromModule( + Module module, boolean includeTest) { + if (workspaceResourcesFeature.isEnabled() + && module.getName().equals(BlazeDataStorage.WORKSPACE_MODULE_NAME)) { + // Returns all the packages in resource modules, and all the workspace packages that + // have previously been asked for. All `res/` directories in our project should belong to a + // resource module. For java sources, IntelliJ will ask for explicit resource package by + // calling `getLightRClasses` at which point we can create the package. This is not completely + // correct and the autocomplete will be slightly off when initial `R` is typed in the editor, + // but this workaround is being used to mitigate issues (b/136685602) while resources + // are re-worked. + return allRClasses; + } else { + return rClasses.values(); + } + } + + @Override + public Collection getLightRClassesDefinedByModule( + Module module, boolean includeTestClasses) { + BlazeRClass rClass = rClassesByModule.get(module); + return rClass == null ? ImmutableSet.of() : ImmutableSet.of(rClass); + } +} diff --git a/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeAutoAndroidDebugger.java b/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeAutoAndroidDebugger.java index 524f7531b3f..08f03d50d8f 100644 --- a/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeAutoAndroidDebugger.java +++ b/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeAutoAndroidDebugger.java @@ -17,21 +17,20 @@ import com.android.ddmlib.Client; import com.android.ddmlib.ClientData; -import com.android.tools.ndk.run.editor.AutoAndroidDebuggerState; -import com.intellij.execution.ExecutionException; import com.intellij.openapi.project.Project; import com.intellij.xdebugger.XDebugSession; +import org.jetbrains.annotations.NotNull; /** Shim for #api212 compat. */ public class BlazeAutoAndroidDebugger extends BlazeAutoAndroidDebuggerBase { + @Override - public XDebugSession attachToClient( - Project project, Client client, AutoAndroidDebuggerState state) throws ExecutionException { + public XDebugSession getExistingDebugSession(@NotNull Project project, @NotNull Client client) { if (isNativeProject(project)) { - log.info("Project has native development enabled. Attaching native debugger."); - return nativeDebugger.attachToClient(project, client, state); + log.info("Project has native development enabled"); + return nativeDebugger.getExistingDebugSession(project, client); } else { - return super.attachToClient(project, client, state); + return super.getExistingDebugSession(project, client); } } diff --git a/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeAndroidDebuggerBase.java b/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeAndroidDebuggerBase.java index 911d90b7711..626e90c20ab 100644 --- a/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeAndroidDebuggerBase.java +++ b/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeAndroidDebuggerBase.java @@ -15,12 +15,18 @@ */ package com.google.idea.blaze.android.cppimpl.debug; +import com.android.ddmlib.Client; import com.android.tools.ndk.run.editor.NativeAndroidDebugger; +import com.android.tools.ndk.run.editor.NativeAndroidDebuggerState; import com.google.idea.blaze.base.model.BlazeProjectData; import com.google.idea.blaze.base.model.primitives.LanguageClass; import com.google.idea.blaze.base.settings.Blaze; import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager; +import com.intellij.execution.ExecutionException; import com.intellij.openapi.project.Project; +import com.intellij.xdebugger.XDebugProcessStarter; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; /** * Extension of {@link NativeAndroidDebugger} with the following key differences compared to {@link @@ -56,4 +62,17 @@ public boolean supportsProject(Project project) { return blazeProjectData != null && blazeProjectData.getWorkspaceLanguageSettings().isLanguageActive(LanguageClass.C); } + + @Override + public XDebugProcessStarter getDebugProcessStarterForExistingProcess( + @NotNull Project project, + @NotNull Client client, + @Nullable String applicationId, + @Nullable NativeAndroidDebuggerState state) + throws ExecutionException { + if (state != null) { + BlazeNativeDebuggerStateSourceMapping.addSourceMapping(project, state); + } + return super.getDebugProcessStarterForExistingProcess(project, client, applicationId, state); + } } diff --git a/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeDebuggerStateSourceMapping.java b/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeDebuggerStateSourceMapping.java new file mode 100644 index 00000000000..640e5f82075 --- /dev/null +++ b/aswb/sdkcompat/as232/com/google/idea/blaze/android/cppimpl/debug/BlazeNativeDebuggerStateSourceMapping.java @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.google.idea.blaze.android.cppimpl.debug; + +import com.android.tools.ndk.run.editor.NativeAndroidDebuggerState; +import com.google.common.collect.ImmutableList; +import com.google.idea.blaze.base.model.primitives.WorkspaceRoot; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; + +/** Maps source directory when attaching to a process */ +public class BlazeNativeDebuggerStateSourceMapping { + public static void addSourceMapping( + @NotNull Project project, @NotNull NativeAndroidDebuggerState state) { + // Source code is always relative to the workspace root in a blaze project. + String workingDirPath = WorkspaceRoot.fromProject(project).directory().getPath(); + state.setWorkingDir(workingDirPath); + + // Remote built binaries may use /proc/self/cwd to represent the working directory + // so we manually map /proc/self/cwd to the workspace root. We used to use + // `plugin.symbol-file.dwarf.comp-dir-symlink-paths = "/proc/self/cwd"` + // to automatically resolve this but it's no longer supported in newer versions of + // LLDB. + String sourceMapToWorkspaceRootCommand = + "settings append target.source-map /proc/self/cwd " + workingDirPath; + ImmutableList startupCommands = + ImmutableList.builder() + .addAll(state.getUserStartupCommands()) + .add(sourceMapToWorkspaceRootCommand) + .build(); + state.setUserStartupCommands(startupCommands); + } +} diff --git a/aswb/sdkcompat/as232/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java b/aswb/sdkcompat/as232/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java new file mode 100644 index 00000000000..be9c3b2d882 --- /dev/null +++ b/aswb/sdkcompat/as232/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java @@ -0,0 +1,64 @@ +/* + * Copyright 2016 The Bazel Authors. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.google.idea.blaze.android.resources; + +import com.android.tools.idea.projectsystem.LightResourceClassService; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import com.google.idea.blaze.base.sync.data.BlazeDataStorage; +import com.google.idea.common.experiments.FeatureRolloutExperiment; +import com.intellij.openapi.module.Module; +import com.intellij.psi.PsiClass; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +/** Implementation of {@link LightResourceClassService} set up at Blaze sync time. */ +public abstract class BlazeLightResourceClassServiceBase implements LightResourceClassService { + + @VisibleForTesting + public static final FeatureRolloutExperiment workspaceResourcesFeature = + new FeatureRolloutExperiment("aswb.workspace.light.class.enabled"); + + Map rClasses = Maps.newHashMap(); + Map rClassesByModule = Maps.newHashMap(); + final Set allRClasses = Sets.newHashSet(); + + @Override + public Collection getLightRClassesAccessibleFromModule(Module module) { + if (workspaceResourcesFeature.isEnabled() + && module.getName().equals(BlazeDataStorage.WORKSPACE_MODULE_NAME)) { + // Returns all the packages in resource modules, and all the workspace packages that + // have previously been asked for. All `res/` directories in our project should belong to a + // resource module. For java sources, IntelliJ will ask for explicit resource package by + // calling `getLightRClasses` at which point we can create the package. This is not completely + // correct and the autocomplete will be slightly off when initial `R` is typed in the editor, + // but this workaround is being used to mitigate issues (b/136685602) while resources + // are re-worked. + return allRClasses; + } else { + return rClasses.values(); + } + } + + @Override + public Collection getLightRClassesDefinedByModule(Module module) { + BlazeRClass rClass = rClassesByModule.get(module); + return rClass == null ? ImmutableSet.of() : ImmutableSet.of(rClass); + } +} diff --git a/aswb/sdkcompat/as232/com/google/idea/blaze/android/run/runner/MobileInstallApplicationDeployer.java b/aswb/sdkcompat/as232/com/google/idea/blaze/android/run/runner/MobileInstallApplicationDeployer.java index f637ec7c654..541cf750686 100644 --- a/aswb/sdkcompat/as232/com/google/idea/blaze/android/run/runner/MobileInstallApplicationDeployer.java +++ b/aswb/sdkcompat/as232/com/google/idea/blaze/android/run/runner/MobileInstallApplicationDeployer.java @@ -15,27 +15,20 @@ */ package com.google.idea.blaze.android.run.runner; +import static com.android.tools.idea.run.tasks.AbstractDeployTask.getAppToInstall; + import com.android.ddmlib.IDevice; -import com.android.tools.deployer.ApkParser; import com.android.tools.deployer.Deployer; import com.android.tools.deployer.DeployerException; -import com.android.tools.deployer.model.Apk; import com.android.tools.deployer.model.App; import com.android.tools.idea.execution.common.ApplicationDeployer; import com.android.tools.idea.execution.common.DeployOptions; -import com.android.tools.idea.log.LogWrapper; -import com.android.tools.idea.run.ApkFileUnit; import com.android.tools.idea.run.ApkInfo; -import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.progress.ProgressIndicator; -import java.nio.file.Path; -import java.util.List; -import java.util.stream.Collectors; import org.jetbrains.annotations.NotNull; /** Deploys mobile install application. */ public class MobileInstallApplicationDeployer implements ApplicationDeployer { - final Logger log = Logger.getInstance(this.getClass()); public MobileInstallApplicationDeployer() {} @@ -45,15 +38,8 @@ public Deployer.Result fullDeploy( @NotNull IDevice device, @NotNull ApkInfo apkInfo, @NotNull DeployOptions deployOptions, - ProgressIndicator indicator) - throws DeployerException { - final List apkPaths = - apkInfo.getFiles().stream() - .map(ApkFileUnit::getApkPath) - .map(Path::toString) - .collect(Collectors.toList()); - final List apks = new ApkParser().parsePaths(apkPaths); - App app = new App(apkInfo.getApplicationId(), apks, device, new LogWrapper(log)); + ProgressIndicator indicator) { + App app = getAppToInstall(apkInfo); return new Deployer.Result(false, false, false, app); } @@ -63,8 +49,7 @@ public Deployer.Result applyChangesDeploy( @NotNull IDevice device, @NotNull ApkInfo app, @NotNull DeployOptions deployOptions, - ProgressIndicator indicator) - throws DeployerException { + ProgressIndicator indicator) { throw new RuntimeException("Apply changes is not supported for mobile-install"); } diff --git a/aswb/sdkcompat/asdev/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java b/aswb/sdkcompat/asdev/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java new file mode 100644 index 00000000000..21516076cc2 --- /dev/null +++ b/aswb/sdkcompat/asdev/com/google/idea/blaze/android/resources/BlazeLightResourceClassServiceBase.java @@ -0,0 +1,66 @@ +/* + * Copyright 2016 The Bazel Authors. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.google.idea.blaze.android.resources; + +import com.android.tools.idea.projectsystem.LightResourceClassService; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import com.google.idea.blaze.base.sync.data.BlazeDataStorage; +import com.google.idea.common.experiments.FeatureRolloutExperiment; +import com.intellij.openapi.module.Module; +import com.intellij.psi.PsiClass; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +/** Implementation of {@link LightResourceClassService} set up at Blaze sync time. */ +public abstract class BlazeLightResourceClassServiceBase implements LightResourceClassService { + + @VisibleForTesting + public static final FeatureRolloutExperiment workspaceResourcesFeature = + new FeatureRolloutExperiment("aswb.workspace.light.class.enabled"); + + Map rClasses = Maps.newHashMap(); + Map rClassesByModule = Maps.newHashMap(); + final Set allRClasses = Sets.newHashSet(); + + @Override + public Collection getLightRClassesAccessibleFromModule( + Module module, boolean includeTest) { + if (workspaceResourcesFeature.isEnabled() + && module.getName().equals(BlazeDataStorage.WORKSPACE_MODULE_NAME)) { + // Returns all the packages in resource modules, and all the workspace packages that + // have previously been asked for. All `res/` directories in our project should belong to a + // resource module. For java sources, IntelliJ will ask for explicit resource package by + // calling `getLightRClasses` at which point we can create the package. This is not completely + // correct and the autocomplete will be slightly off when initial `R` is typed in the editor, + // but this workaround is being used to mitigate issues (b/136685602) while resources + // are re-worked. + return allRClasses; + } else { + return rClasses.values(); + } + } + + @Override + public Collection getLightRClassesDefinedByModule( + Module module, boolean includeTestClasses) { + BlazeRClass rClass = rClassesByModule.get(module); + return rClass == null ? ImmutableSet.of() : ImmutableSet.of(rClass); + } +} diff --git a/aswb/src/com/google/idea/blaze/android/resources/BlazeLightResourceClassService.java b/aswb/src/com/google/idea/blaze/android/resources/BlazeLightResourceClassService.java index 87e140d66fb..5285a5dda47 100644 --- a/aswb/src/com/google/idea/blaze/android/resources/BlazeLightResourceClassService.java +++ b/aswb/src/com/google/idea/blaze/android/resources/BlazeLightResourceClassService.java @@ -23,7 +23,6 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; -import com.google.common.collect.Sets; import com.google.idea.blaze.base.sync.data.BlazeDataStorage; import com.google.idea.common.experiments.BoolExperiment; import com.google.idea.common.experiments.FeatureRolloutExperiment; @@ -42,7 +41,8 @@ import org.jetbrains.annotations.Nullable; /** Implementation of {@link LightResourceClassService} set up at Blaze sync time. */ -public class BlazeLightResourceClassService implements LightResourceClassService { +public class BlazeLightResourceClassService extends BlazeLightResourceClassServiceBase + implements LightResourceClassService { @VisibleForTesting public static final FeatureRolloutExperiment workspaceResourcesFeature = @@ -57,13 +57,10 @@ public class BlazeLightResourceClassService implements LightResourceClassService private final Project project; - private Map rClasses = Maps.newHashMap(); - private Map rClassesByModule = Maps.newHashMap(); private Map rClassPackages = Maps.newHashMap(); private Map workspaceRClasses = Maps.newHashMap(); private Set workspaceRClassNames = ImmutableSet.of(); - private final Set allRClasses = Sets.newHashSet(); private PsiManager psiManager; public static BlazeLightResourceClassService getInstance(Project project) { @@ -196,30 +193,6 @@ private BlazeRClass getRClassForWorkspace(String qualifiedName, GlobalSearchScop } @Override - public Collection getLightRClassesAccessibleFromModule( - Module module, boolean includeTest) { - if (workspaceResourcesFeature.isEnabled() - && module.getName().equals(BlazeDataStorage.WORKSPACE_MODULE_NAME)) { - // Returns all the packages in resource modules, and all the workspace packages that - // have previously been asked for. All `res/` directories in our project should belong to a - // resource module. For java sources, IntelliJ will ask for explicit resource package by - // calling `getLightRClasses` at which point we can create the package. This is not completely - // correct and the autocomplete will be slightly off when initial `R` is typed in the editor, - // but this workaround is being used to mitigate issues (b/136685602) while resources - // are re-worked. - return allRClasses; - } else { - return rClasses.values(); - } - } - - // @Override #api4.0: override added in as4.1 - public Collection getLightRClassesDefinedByModule( - Module module, boolean includeTestClasses) { - BlazeRClass rClass = rClassesByModule.get(module); - return rClass == null ? ImmutableSet.of() : ImmutableSet.of(rClass); - } - public Collection getLightRClassesContainingModuleResources(Module module) { return rClasses.values(); }