*/

package org.gradle.nativeplatform.internal.modulemap;

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;
import org.gradle.internal.hash.Hashing;

import java.io.Serializable;
import java.util.List;

/**
 * Represents a mapping between a module and the header files associated with the module.
 *
 * @since 4.5
 */
public class ModuleMap implements Serializable {

            .open();
    }

    public File getModuleMapFile(final ModuleMap moduleMap) {
        final String hash = moduleMap.getHashCode().toCompactString();
        return cache.useCache(() -> {
            File dir = new File(cache.getBaseDir(), "maps/" + hash + "/" + moduleMap.getModuleName());
            File moduleMapFile = new File(dir, "module.modulemap");
            if (!moduleMapFile.isFile()) {

                        }

                        ModuleMap moduleMap;
                        if (moduleMaps.containsKey(id)) {
                            moduleMap = moduleMaps.get(id);
                        } else {
                            moduleMap = new ModuleMap(moduleName, new ArrayList<>());
                            moduleMaps.put(id, moduleMap);
                        }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.internal.modulemap

import spock.lang.Specification
import spock.lang.TempDir

import static org.gradle.nativeplatform.internal.modulemap.GenerateModuleMapFile.generateFile
import static org.gradle.util.internal.TextUtil.normaliseLineSeparators

        appSwiftIncludeDirs[2].file("module.modulemap").assertExists()

        def helloSwiftIncludeDirs = toFiles(xcodeProject("hello/hello.xcodeproj").projectFile.indexTarget.getBuildSettings().SWIFT_INCLUDE_PATHS)
        helloSwiftIncludeDirs.size() == 2
        helloSwiftIncludeDirs[0] == file("cppGreeter/src/main/public")
        helloSwiftIncludeDirs[1].file("module.modulemap").assertExists()

        when:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.internal.modulemap;

import com.google.common.collect.Lists;
import com.google.common.io.Files;
import org.apache.commons.io.FileUtils;
import org.gradle.api.UncheckedIOException;
import org.gradle.api.specs.Spec;

 * @param <T> the contract type for all items
 */
@Incubating
public interface ModelMap<T> extends Iterable<T>, ModelElement {
    /**
     * Returns a collection containing the items from this collection which are of the specified type.
     *
     * @param type The type.
     * @param <S> The type.
     * @return The collection.
     */
    <S> ModelMap<S> withType(Class<S> type);

    /**

  OwningOpRef<ModuleOp> module_op =
      ParseModuleOpString(kConstantOpWithRankFour);
  ASSERT_TRUE(module_op);

  ASSERT_FALSE(module_op->getBodyRegion().empty());
  ASSERT_FALSE(module_op->getBodyRegion().front().empty());

  auto constant_op = dyn_cast_or_null<mlir::stablehlo::ConstantOp>(
      module_op->getBodyRegion().front().front());
  ASSERT_THAT(constant_op, NotNull());

};

func::FuncOp GetMainFuncOp(ModuleOp module_op) {
  for (auto func_op : module_op.getOps<func::FuncOp>()) {
    if (func_op.getSymName() == "main") {
      return func_op;
    }
  }
  return {};
}

TEST_F(ConvertAssetArgsTest, ConvertsSingleAssetArg) {
  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(R"mlir(
    module {

  // MLIR @main function corresponds to the TF function "main_original".
  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(R"mlir(
    func.func private @main(%arg: tensor<1x2xf32>) -> (tensor<1x2xf32>) attributes {tf._original_func_name = "main_original"} {
      return %arg : tensor<1x2xf32>
    }
  )mlir");
  ASSERT_TRUE(module_op);

  absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases;