demangle: parse C++20 pointer-to-member conversions

Author: ianlancetaylor

ast.go

@@ -2549,6 +2549,70 @@ func (so *Subobject) goString(indent int, field string) string {
 		indent+2, "", so.PastEnd)
 }
 
+// PtrMemCast is a conversion of an expression to a pointer-to-member
+// type.  This is used for C++20 manglings of class types used as the
+// type of non-type template arguments.
+//
+// See https://github.com/itanium-cxx-abi/cxx-abi/issues/47.
+type PtrMemCast struct {
+	Type   AST
+	Expr   AST
+	Offset int
+}
+
+func (pmc *PtrMemCast) print(ps *printState) {
+	ps.writeString("(")
+	ps.print(pmc.Type)
+	ps.writeString(")(")
+	ps.print(pmc.Expr)
+	ps.writeString(")")
+}
+
+func (pmc *PtrMemCast) Traverse(fn func(AST) bool) {
+	if fn(pmc) {
+		pmc.Type.Traverse(fn)
+		pmc.Expr.Traverse(fn)
+	}
+}
+
+func (pmc *PtrMemCast) Copy(fn func(AST) AST, skip func(AST) bool) AST {
+	if skip(pmc) {
+		return nil
+	}
+	typ := pmc.Type.Copy(fn, skip)
+	expr := pmc.Expr.Copy(fn, skip)
+	if typ == nil && expr == nil {
+		return nil
+	}
+	if typ == nil {
+		typ = pmc.Type
+	}
+	if expr == nil {
+		expr = pmc.Expr
+	}
+	pmc = &PtrMemCast{
+		Type:   typ,
+		Expr:   expr,
+		Offset: pmc.Offset,
+	}
+	if r := fn(pmc); r != nil {
+		return r
+	}
+	return pmc
+}
+
+func (pmc *PtrMemCast) GoString() string {
+	return pmc.goString(0, "")
+}
+
+func (pmc *PtrMemCast) goString(indent int, field string) string {
+	return fmt.Sprintf("%*s%sPtrMemCast:\n%s\n%s\n%*sOffset: %d",
+		indent, "", field,
+		pmc.Type.goString(indent+2, "Type: "),
+		pmc.Expr.goString(indent+2, "Expr: "),
+		indent+2, "", pmc.Offset)
+}
+
 // New is a use of operator new in an expression.
 type New struct {
 	Op    AST

cases_test.go

@@ -30178,46 +30178,58 @@ var casesExpectedFailures = map[string]bool{
 	"_ZZZZN6abcdef9abcdefghi29abcdefabcdefabcdefabcefabcdef27xxxxxxxxxxxxxxxxxxxxxxxxxxxEN4absl8DurationERKNSt3__u12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS1_19yyyyyyyyyyyyyyyyyyyEENK3$_5clEvENKUlvE_clEvE6zzzzzz": true,
 	"_Z1fIXtl1BadsoiL_Z6nestedE_EEEEvv":                      true,
 	"_Z1fIXtl1BcvPiplcvPcadL_Z7derivedELl16EEEEvv":           true,
-	"_Z1fIXtl1DmcM7DerivedKiadL_ZN11MoreDerived1zEEn8EEEEvv": true,
 	"_Z1fIXtl1Edi1nLi42EEEEvv":                               true,
 	"_Z1h1XIJZ1fIiEDaOT_E1AZ1gIdEDaS2_E1BEE":                 true,
 	"_ZN1A1gIiEEDTcldtptfpT1b1fIT_EEEv":                      true,
 }
 
 // caseExceptions is a list of exceptions from the LLVM list that we
 // do not handle the same as the LLVM demangler.  We keep a list of
-// exceptions so that we can use an exact copy of the test cases.
-var casesExceptions = map[string]bool{
+// exceptions so that we can use an exact copy of the test cases.  We
+// map to an empty string if we expect a demangling failure; this
+// differs from caseExpectedFailures in that we've decided that we
+// intentionally should not demangle this case.  Otherwise this maps
+// to the expected demangling.
+var casesExceptions = map[string]string{
+	"_Z1fIXtl1DmcM7DerivedKiadL_ZN11MoreDerived1zEEn8EEEEvv" : "void f<D{(int const Derived::*)(&MoreDerived::z)}>()",
 }
 
 func TestCases(t *testing.T) {
+	t.Parallel()
 	expectedFails := 0
 	found := make(map[string]bool)
 	for _, test := range cases {
 		expectedFail := casesExpectedFailures[test[0]]
-		exception := casesExceptions[test[0]]
+		exception, haveException := casesExceptions[test[0]]
+		if expectedFail && haveException {
+			t.Errorf("test case error: %s in both expectedFailures and exceptions", test[0])
+		}
+		want := test[1]
+		if haveException && exception != "" {
+			want = exception
+		}
 		if got, err := ToString(test[0]); err != nil {
-			if expectedFail {
+			if expectedFail || (haveException && exception == "") {
 				t.Logf("demangling %s: expected failure: error %v", test[0], err)
-				expectedFails++
-				found[test[0]] = true
-			} else if exception {
-				t.Logf("demangling %s: ignore expected difference: error %v", test[0], err)
+				if expectedFail {
+					expectedFails++
+					found[test[0]] = true
+				}
 			} else {
 				t.Errorf("demangling %s: unexpected error %v", test[0], err)
 			}
-		} else if got != test[1] {
+		} else if got != want {
 			if expectedFail {
-				t.Logf("demangling %s: expected failure: got %s, want %s", test[0], got, test[1])
+				t.Logf("demangling %s: expected failure: got %s, want %s", test[0], got, want)
 				expectedFails++
 				found[test[0]] = true
-			} else if exception {
-				t.Logf("demangling %s: ignore expected difference: got %s, want %s", test[0], got, test[1])
+			} else if haveException && exception == "" {
+				t.Errorf("demangling %s: expected to fail, but succeeded with %s", test[0], got)
 			} else {
-				t.Errorf("demangling %s: got %s, want %s", test[0], got, test[1])
+				t.Errorf("demangling %s: got %s, want %s", test[0], got, want)
 			}
-		} else if expectedFail || exception {
-			t.Errorf("demangling %s: expected to fail, but succeeded", test[0])
+		} else if expectedFail || (haveException && exception == "") {
+			t.Errorf("demangling %s: expected to fail, but succeeded with %s", test[0], got)
 			if expectedFail {
 				found[test[0]] = true
 			}

demangle.go

@@ -1968,6 +1968,7 @@ func (st *state) exprList(stop byte) AST {
 //              ::= dc <type> <expression>
 //              ::= sc <type> <expression>
 //              ::= cc <type> <expression>
+//              ::= mc <parameter type> <expr> [<offset number>] E
 //              ::= rc <type> <expression>
 //              ::= ti <type>
 //              ::= te <expression>
@@ -2067,6 +2068,23 @@ func (st *state) expression() AST {
 		st.cvQualifiers()
 		index := st.compactNumber()
 		return &FunctionParam{Index: index + 1}
+	} else if st.str[0] == 'm' && len(st.str) > 1 && st.str[1] == 'c' {
+		st.advance(2)
+		typ := st.demangleType(false)
+		expr := st.expression()
+		offset := 0
+		if len(st.str) > 0 && (st.str[0] == 'n' || isDigit(st.str[0])) {
+			offset = st.number()
+		}
+		if len(st.str) == 0 || st.str[0] != 'E' {
+			st.fail("expected E after pointer-to-member conversion")
+		}
+		st.advance(1)
+		return &PtrMemCast{
+			Type:   typ,
+			Expr:   expr,
+			Offset: offset,
+		}
 	} else if isDigit(st.str[0]) || (st.str[0] == 'o' && len(st.str) > 1 && st.str[1] == 'n') {
 		if st.str[0] == 'o' {
 			// Skip operator function ID.

expected_test.go

@@ -50,6 +50,7 @@ var exceptions = map[string]bool{
 // the syntax.  We ignore all tests that are not --format=gnu-v3 or
 // --format=auto with a string starting with _Z.
 func TestExpected(t *testing.T) {
+	t.Parallel()
 	f, err := os.Open(filename)
 	if err != nil {
 		t.Fatal(err)