Fix wrong mode on output for macros that shadow global macros

Testcase: Define a math macro \AA, overriding the definition of \AA from
lib/symbols, then insert it in math mode.

* Before this commit: \text{\AA}, and \lyxmathsym{\AA} after deleting \text, but
  displayed like \AA.

* After this commit: \text{\AA} is inserted, but one gets \AA after deleting
  \text. The output is now consistent with the display and the meaning.

* Expected: only \AA is inserted. This is unfortuately not what one gets; for
  this to work, the scope of the macros would need to be resolved upon creating
  the inset.

src/mathed/MathMacro.cpp

@@ -823,12 +823,34 @@ size_t MathMacro::appetite() const
 
 InsetMath::mode_type MathMacro::currentMode() const
 {
-	// User defined macros are always assumed to be mathmode macros.
+	// There is no way to guess the mode of user defined macros, so they are
-	// Only the global macros defined in lib/symbols may be textmode.
+	// always assumed to be mathmode.  Only the global macros defined in
+	// lib/symbols may be textmode.
+	mode_type mode = modeToEnsure();
+	return (mode == UNDECIDED_MODE) ? MATH_MODE : mode;
+}
 
-	MacroData const * data = MacroTable::globalMacros().get(name());
+
-	bool textmode = data && data->symbol() && data->symbol()->extra == "textmode";
+InsetMath::mode_type MathMacro::modeToEnsure() const
-	return textmode ? TEXT_MODE : MATH_MODE;
+{
+	// User defined macros can be either text mode or math mode for output and
+	// display. There is no way to guess. For global macros defined in
+	// lib/symbols, we ensure textmode if flagged as such, otherwise we ensure
+	// math mode.
+	if (MacroData const * m = macroBackup())
+		if (m->symbol())
+			return (m->symbol()->extra == "textmode") ? TEXT_MODE : MATH_MODE;
+	return UNDECIDED_MODE;
+}
+
+
+MacroData const * MathMacro::macroBackup() const
+{
+	if (macro())
+		return &d->macroBackup_;
+	if (MacroData const * data = MacroTable::globalMacros().get(name()))
+		return data;
+	return nullptr;
 }
 
 
@@ -1009,12 +1031,9 @@ bool MathMacro::folded() const
 
 void MathMacro::write(WriteStream & os) const
 {
-	MacroData const * data = MacroTable::globalMacros().get(name());
+	mode_type mode = modeToEnsure();
-	bool textmode_macro = data && data->symbol()
+	bool textmode_macro = mode == TEXT_MODE;
-				   && data->symbol()->extra == "textmode";
+	bool needs_mathmode = mode == MATH_MODE;
-	bool needs_mathmode = data && (!data->symbol()
-				       || data->symbol()->extra != "textmode");
-
 	MathEnsurer ensurer(os, needs_mathmode, true, textmode_macro);
 
 	// non-normal mode

src/mathed/MathMacro.h

@@ -122,7 +122,7 @@ public:
 
 	///
 	docstring name() const;
-	///
+	/// FIXME: Often dangling.
 	MacroData const * macro() const;
 	///
 	docstring macroName() const;
@@ -164,6 +164,14 @@ protected:
 	void attachArguments(std::vector<MathData> const & args, size_t arity, int optionals);
 
 private:
+	/// Math mode for output and display. UNDECIDED for user macros: they could
+	/// be either.
+	mode_type modeToEnsure() const;
+	/// This function is needed for now because of two shortfalls of the current
+	/// implementation: the macro() pointer is often dangling, in which case we
+	/// fall back to a backup copy, and the macro is not known at inset
+	/// creation, in which case we fall back to the global macro with this name.
+	MacroData const * macroBackup() const;
 	///
 	virtual Inset * clone() const;
 	///