#include "${functionName}.h"

// Include functions from dependencies
<% projectDeps.each { p ->
  sourceFiles.times { %>
#include "${p}lib${it + 1}.h"
<%
  }
} %>

<% functionCount.times { %>
long CPP_${functionName}_${it + 1} () {
  long sum = 1;
  // Call functions defined in dependent projects.
  <% projectDeps.each { p ->
    sourceFiles.times {
      def functionName = "${p}lib${it + 1}"
      functionCount.times {
  %>

#ifndef PROJECT_HEADER_${functionName}_H
#define PROJECT_HEADER_${functionName}_H
<% functionCount.times { %>
long CPP_${functionName}_${it + 1} ();
<% } %>

  return function_aliases;
}

void UpdateFunctionAliases(
    absl::flat_hash_map<FunctionName, FunctionAlias>& function_aliases,
    ModuleOp module_op) {
  absl::flat_hash_set<FunctionName> existing_func_names;
  module_op->walk([&](func::FuncOp func_op) {
    FunctionName func_name = func_op.getSymName().str();
    existing_func_names.insert(func_name);

#define STDIO <stdio.h>
#include STDIO
<% }%>

int main () {
  long sum = 1;
  <% sourceFiles.times {
    def functionName = "lib${it + 1}"
    if (projectName != 'root') {
      functionName = "${projectName}${functionName}"
    }
    functionCount.times {
  %>
  sum += CPP_${functionName}_${it + 1}();
  <%
    }
  } %>
  printf("You made %d function calls!", sum);
  return 0;

      return %arg : tensor<1x2xf32>
    }
  )mlir");
  ASSERT_TRUE(module_op);

  absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases;
  UpdateFunctionAliases(function_aliases, *module_op);
  EXPECT_THAT(function_aliases, IsEmpty());
}

TEST_F(UpdateFunctionAliasesTest, AliasUpdatedByMlirFunctionName) {

            Map classArgs = projectArgs + [functionName: fName]
            def headersDir = classArgs.projectType == 'exe' ? 'headers' : 'public'
            generateWithTemplate(projectDir, "src/main/cpp/${classArgs.functionName}.cpp", 'lib.cpp', classArgs)
            generateWithTemplate(projectDir, "src/main/${headersDir}/${classArgs.functionName}.h", 'lib.h', classArgs)
        }
    }

        }
        testProject.sourceFiles.times { s ->
            args.moduleCount.times { m ->
                Map classArgs = args + [componentName: "lib${m + 1}", functionName: "lib${s + 1}"]
                generateWithTemplate(projectDir, "src/${classArgs.componentName}/c/${classArgs.functionName}.c", 'lib.c', classArgs)
            }
        }
    }

    const std::vector<std::string>& signature_keys,
    MLIRContext& ctx ABSL_ATTRIBUTE_LIFETIME_BOUND);

// Gets the function aliases from the SavedModel.
absl::StatusOr<absl::flat_hash_map<FunctionName, FunctionAlias>>
GetFunctionAliases(absl::string_view saved_model_path,
                   const std::unordered_set<std::string>& tags);

// Updates the function aliases. `module_op` may have different

	type locKey struct {
		functionName, fileName string
	}
	locs := map[locKey]*profile.Location{}

	internLoc := func(locKey locKey) *profile.Location {
		loc, found := locs[locKey]
		if found {
			return loc
		}

		function := &profile.Function{
			ID:       nextFuncID,
			Name:     locKey.functionName,
			Filename: locKey.fileName,
		}
		nextFuncID++

	"go/parser"
	"go/printer"
	"go/token"
	"strings"
)

func parseFunc(filename, functionname string) (fun *ast.FuncDecl, fset *token.FileSet) {
	fset = token.NewFileSet()
	if file, err := parser.ParseFile(fset, filename, nil, 0); err == nil {
		for _, d := range file.Decls {
			if f, ok := d.(*ast.FuncDecl); ok && f.Name.Name == functionname {
				fun = f
				return
			}
		}
	}
	panic("function not found")
}