void SetImporter(std::unique_ptr<TacImporter> importer) {
    importer_ = std::move(importer);
  }

  void SetExporter(std::unique_ptr<TacExporter> exporter) {
    exporter_ = std::move(exporter);
  }

  // Returns pointer to the TargetHardware that is identified by 'hardware_name'
  // Returns NULL If no hardware with this name found.
  const tac::TargetHardware* GetTargetHardware(

            lock()

        then:
        def local = scope.localClassLoader.loadClass(TestClass1.name)
        def exported = scope.exportClassLoader.loadClass(TestClass2.name)
        scope.defines(local)
        scope.defines(exported)
        !scope.defines(TestClass1)
        !scope.defines(TestClass2)
    }

    def "requesting loaders before locking creates pessimistic setup"() {
        given:

                .getValue()));
      }

      TF_RETURN_IF_ERROR(exporter.AddInstructionNode(&inner_op));
    } else {
      TF_RETURN_IF_ERROR(exporter.AddInstructionNode(&inst));
    }
  }
  // Adds edges between the argument, operation and return nodes.
  for (Operation& inst : graph_op.GetBody()) {
    TF_RETURN_IF_ERROR(exporter.AddEdge(&inst));
  }

                .getValue()));
      }

      TF_RETURN_IF_ERROR(exporter.AddInstructionNode(&inner_op));
    } else {
      TF_RETURN_IF_ERROR(exporter.AddInstructionNode(&inst));
    }
  }
  // Adds edges between the argument, operation and return nodes.
  for (Operation& inst : graph_op.GetBody()) {
    TF_RETURN_IF_ERROR(exporter.AddEdge(&inst));
  }

  mlir::MLIRContext context_;
  llvm::SourceMgr source_mgr_;
  std::unique_ptr<mlir::SourceMgrDiagnosticHandler> source_mgr_handler_;
};

// TAC Exporter. It exports the provided Module to a tflite file.
class TfLiteExporter : public mlir::TFL::tac::TacExporter {
 public:
  // Exporter configuration options.
  struct Options {
    bool export_runtime_metadata = false;
    bool output_mlir = false;
    std::string output_file_name;

  if (!importer_) {
    return absl::Status(absl::StatusCode::kFailedPrecondition,
                        "Null Importer provided");
  }
  if (!exporter_) {
    return absl::Status(absl::StatusCode::kFailedPrecondition,
                        "Null Exporter provided");
  }

  auto module_status = importer_->Import();
  if (!module_status.ok()) {
    return module_status.status();
  }

package tx3_test

import "vendor.org/tx3"
import "testing"

var Found = tx3.Exported

func TestNop(t *testing.T) {}

-- $GOPATH/src/github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx3/export_test.go --
package tx3

var Exported = true

-- $GOPATH/src/github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx3/tx3.go --
package tx3

    public ClassRealm getClassRealm() {
        return realm;
    }

    /**
     * Returns artifacts exported by the extension, identified by groupId:artifactId string key.
     */
    public Set<String> getExportedArtifacts() {
        return artifacts;
    }

    /**
     * Returns classpath elements exported by the extension.
     */
    public Set<String> getExportedPackages() {
        return packages;
    }

Donát Csikós <******@****.***> 1708358577 +0100

        return exported == that.exported
            && Objects.equal(path, that.path)
            && Objects.equal(accessRules, that.accessRules)
            && Objects.equal(getNativeLibraryLocation(), that.getNativeLibraryLocation());
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(path, exported, accessRules, getNativeLibraryLocation());
    }