Merge changes I19f0e104,I7994bee6

* changes:
  Emit mkpatsubst call for $(patsubst ...)
  Emit mksubst call for $(subst ...)

mk2rbc/mk2rbc.go

@@ -93,13 +93,14 @@ var knownFunctions = map[string]struct {
 	"is-vendor-board-platform":            {"!is-vendor-board-platform", starlarkTypeBool},
 	callLoadAlways:                        {"!inherit-product", starlarkTypeVoid},
 	callLoadIf:                            {"!inherit-product-if-exists", starlarkTypeVoid},
+	"patsubst":                            {baseName + ".mkpatsubst", starlarkTypeString},
 	"produce_copy_files":                  {baseName + ".produce_copy_files", starlarkTypeList},
 	"require-artifacts-in-path":           {baseName + ".require_artifacts_in_path", starlarkTypeVoid},
 	"require-artifacts-in-path-relaxed":   {baseName + ".require_artifacts_in_path_relaxed", starlarkTypeVoid},
 	// TODO(asmundak): remove it once all calls are removed from configuration makefiles. see b/183161002
 	"shell":    {baseName + ".shell", starlarkTypeString},
 	"strip":    {baseName + ".mkstrip", starlarkTypeString},
-	"subst":    {baseName + ".subst", starlarkTypeString},
+	"subst":    {baseName + ".mksubst", starlarkTypeString},
 	"warning":  {baseName + ".mkwarning", starlarkTypeVoid},
 	"word":     {baseName + "!word", starlarkTypeString},
 	"wildcard": {baseName + ".expand_wildcard", starlarkTypeList},
@@ -509,13 +510,7 @@ func (ctx *parseContext) handleAssignment(a *mkparser.Assignment) {
 		}
 		inferred_type := asgn.value.typ()
 		if inferred_type != starlarkTypeUnknown {
-			if ogv, ok := lhs.(*otherGlobalVariable); ok {
-				ogv.typ = inferred_type
-			} else if pcv, ok := lhs.(*productConfigVariable); ok {
-				pcv.typ = inferred_type
-			} else {
-				panic(fmt.Errorf("cannot assign new type to a variable %s, its flavor is %T", lhs.name(), lhs))
-			}
+			lhs.setValueType(inferred_type)
 		}
 	}
 	if lhs.valueType() == starlarkTypeList {
@@ -1085,8 +1080,8 @@ func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeSt
 	switch expr.name {
 	case "word":
 		return ctx.parseWordFunc(node, args)
-	case "subst":
-		return ctx.parseSubstFunc(node, args)
+	case "subst", "patsubst":
+		return ctx.parseSubstFunc(node, expr.name, args)
 	default:
 		for _, arg := range args.Split(",") {
 			arg.TrimLeftSpaces()
@@ -1101,24 +1096,33 @@ func (ctx *parseContext) parseReference(node mkparser.Node, ref *mkparser.MakeSt
 	return expr
 }
 
-func (ctx *parseContext) parseSubstFunc(node mkparser.Node, args *mkparser.MakeString) starlarkExpr {
+func (ctx *parseContext) parseSubstFunc(node mkparser.Node, fname string, args *mkparser.MakeString) starlarkExpr {
 	words := args.Split(",")
 	if len(words) != 3 {
-		return ctx.newBadExpr(node, "subst function should have 3 arguments")
+		return ctx.newBadExpr(node, "%s function should have 3 arguments", fname)
 	}
 	if !words[0].Const() || !words[1].Const() {
-		return ctx.newBadExpr(node, "subst function's from and to arguments should be constant")
+		return ctx.newBadExpr(node, "%s function's from and to arguments should be constant", fname)
 	}
 	from := words[0].Strings[0]
 	to := words[1].Strings[0]
 	words[2].TrimLeftSpaces()
 	words[2].TrimRightSpaces()
 	obj := ctx.parseMakeString(node, words[2])
+	typ := obj.typ()
+	if typ == starlarkTypeString && fname == "subst" {
+		// Optimization: if it's $(subst from, to, string), emit string.replace(from, to)
+		return &callExpr{
+			object:     obj,
+			name:       "replace",
+			args:       []starlarkExpr{&stringLiteralExpr{from}, &stringLiteralExpr{to}},
+			returnType: typ,
+		}
+	}
 	return &callExpr{
-		object:     obj,
-		name:       "replace",
-		args:       []starlarkExpr{&stringLiteralExpr{from}, &stringLiteralExpr{to}},
-		returnType: starlarkTypeString,
+		name:       fname,
+		args:       []starlarkExpr{&stringLiteralExpr{from}, &stringLiteralExpr{to}, obj},
+		returnType: obj.typ(),
 	}
 }
 

mk2rbc/mk2rbc_test.go

@@ -628,6 +628,7 @@ def init(g, handle):
 PRODUCT_COPY_FILES := $(addprefix pfx-,a b c)
 PRODUCT_COPY_FILES := $(addsuffix .sff, a b c)
 PRODUCT_NAME := $(word 1, $(subst ., ,$(TARGET_BOARD_PLATFORM)))
+$(info $(patsubst %.pub,%,$(PRODUCT_ADB_KEYS)))
 
 `,
 		expected: `load("//build/make/core:product_config.rbc", "rblf")
@@ -637,6 +638,23 @@ def init(g, handle):
   cfg["PRODUCT_COPY_FILES"] = rblf.addprefix("pfx-", "a b c")
   cfg["PRODUCT_COPY_FILES"] = rblf.addsuffix(".sff", "a b c")
   cfg["PRODUCT_NAME"] = ((g.get("TARGET_BOARD_PLATFORM", "")).replace(".", " ")).split()[0]
+  rblf.mkinfo("product.mk", rblf.mkpatsubst("%.pub", "%", g.get("PRODUCT_ADB_KEYS", "")))
+`,
+	},
+	{
+		desc:   "subst in list",
+		mkname: "product.mk",
+		in: `
+files = $(call find-copy-subdir-files,*,from,to)
+PRODUCT_COPY_FILES += $(subst foo,bar,$(files))
+`,
+		expected: `load("//build/make/core:product_config.rbc", "rblf")
+
+def init(g, handle):
+  cfg = rblf.cfg(handle)
+  _files = rblf.find_and_copy("*", "from", "to")
+  rblf.setdefault(handle, "PRODUCT_COPY_FILES")
+  cfg["PRODUCT_COPY_FILES"] += rblf.mksubst("foo", "bar", _files)
 `,
 	},
 	{

mk2rbc/variable.go

@@ -26,6 +26,7 @@ type variable interface {
 	emitSet(gctx *generationContext, asgn *assignmentNode)
 	emitDefined(gctx *generationContext)
 	valueType() starlarkType
+	setValueType(t starlarkType)
 	defaultValueString() string
 	isPreset() bool
 }
@@ -44,6 +45,10 @@ func (v baseVariable) valueType() starlarkType {
 	return v.typ
 }
 
+func (v *baseVariable) setValueType(t starlarkType) {
+	v.typ = t
+}
+
 func (v baseVariable) isPreset() bool {
 	return v.preset
 }
@@ -279,7 +284,7 @@ func (ctx *parseContext) addVariable(name string) variable {
 		} else if name == strings.ToLower(name) {
 			// Heuristics: if variable's name is all lowercase, consider it local
 			// string variable.
-			v = &localVariable{baseVariable{nam: name, typ: starlarkTypeString}}
+			v = &localVariable{baseVariable{nam: name, typ: starlarkTypeUnknown}}
 		} else {
 			vt := starlarkTypeUnknown
 			if strings.HasPrefix(name, "LOCAL_") {