MatrixSymbol latex parsing causes invalid behaviour

[LemurPwned]

python3.7.5
sympy version: 1.7
numpy version: 1.19.5

Base case (working)

The code below executes normally

A = sym.MatrixSymbol("A", 3, 3)
x1, x2, x3 = sym.symbols("x1 x2 x3")
x = sym.Matrix([x1, x2, x3])

# this produces (3x3)x(3x1) = (3x1)
r = A * x
f = sym.lambdify([x1, x2, x3, A], r, "numpy")

f(1, 2, 3, np.array([[0, 0, 0], [0, 0, 0], [0, 0, 1]])) 

returns

array([[0],  [0],  [3]]) 

Modified case (fails)

However, when I change A = sym.MatrixSymbol("A", 3, 3) to A = sym.MatrixSymbol("A_{whatever}", 3, 3) this seems to break things, and this line

f(1, 2, 3, np.array([[0, 0, 0], [0, 0, 0], [0, 0, 1]])) 

results in an error:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-299-a4adefb7e356> in <module>
      7 f = sym.lambdify([x1, x2, x3, A], r, "numpy")
      8 
----> 9 f(1, 2, 3, np.array([[0, 0, 0], [0, 0, 0], [0, 0, 1]]))

<lambdifygenerated-41> in _lambdifygenerated(x1, x2, x3, Dummy_507)
      1 def _lambdifygenerated(x1, x2, x3, Dummy_507):
----> 2     return ((array([[x1], [x2], [x3]])).dot(Dummy_507))

ValueError: shapes (3,1) and (3,3) not aligned: 1 (dim 1) != 3 (dim 0)

Is this expected behaviour? A_1 or A_whatever, etc. works fine.
I have spent some time debugging this, since A_{longer text} is a valid Latex expression for long subscripts.
Should A = sym.MatrixSymbol("A_{whatever}", 3, 3) raise some parsing error before proceeding?

[oscarbenjamin]

In the code printer if you use a name that is not a valid python identifier it has to be replaced by a different name (in the _EvaluatorPrinter._preprocess method):

sympy/sympy/utilities/lambdify.py

Lines 1096 to 1101 in 25216a2

	def _preprocess(self, args, expr):
	"""Preprocess args, expr to replace arguments that do not map
	to valid Python identifiers.
	Returns string form of args, and updated expr.
	"""

That replaces the MatrixSymbol with a Dummy but MatMul sees the Dummy as a commutative scalar and swaps the order of multiplication.

It would be better if the code printer didn't actually modify the expression at all and just hooked into the way that symbols are printed to change the names at that point.