Downsides of defining $\models$ to be false when there's a mismatch in signature between the structure and formula. The way that $M \models \varphi$ is usually defined, we know implicitly that for some $L$, $M$ is an $L$-structure and $\varphi$ is an $L$-sentence.
I'm curious what the downsides are to defining $M \models \varphi$ to be false in the event that $\varphi$ contains a non-logical symbol that $M$ does not define. My motivation for doing this is to reduce the need to talk about languages explicitly in the statement of theorems and make language-altering constructions like Henkinization and Skolemization (inspired by this question) give me back an entity of the same sort as the one I started out with.
For example, if $M_0$ is the empty structure, then $ M_0 \models c = c$ would be false because $M_0$ does not assign a denotation to $c$.

The statement of the following very basic theorem about homomorphisms seems nice because we don't need to explicitly mention languages
Let $A$ and $B$ be structures.
If $B \models \text{Diag}^+(A)$, then there exists a homomorphism $h : A \to B$.
If there exists a homomorphism $h : A \to B$, then for some extension of $B$ $B'$, it holds that $B' \models \text{Diag}^+(A)$.
The definition of truth in a model is a bit more complicated now.
Let $M \models t_1 = t_2$ where $t_1, t_2$ are closed terms hold if and only if they have the same denotation and all of their vocabulary symbols are defined in $M$.
Let $M \models R(t_1, \cdots, t_n)$ hold if and only if $\langle t_1 \cdots t_n \rangle$ is in the denotation of $R$ and every vocabulary symbol in $t_1 \cdots t_n$ as well as the symbol $R$ are interpreted in $M$.
Let $M \models \lnot \varphi$ hold if and only if every vocabulary symbol in $\varphi$ is interpreted in $M$ and it does not hold that $M \models \varphi$.
Let $M \models \varphi \land \psi$ hold if and only if $M \models \varphi$ holds and $M \models \psi$ holds.
Let $M \models \exists x \mathop. \varphi(x)$ hold if and only if there exists an $M'$ that extends $M$ with a definition of a fresh constant symbol $c$ so that $M \models \varphi(c)$.
Let $M \models \varphi(x)$ where $x$ is a free variable hold if and only if $M \models \lnot \exists x \mathop. \lnot \varphi(x)$ holds.
 A: In the comments, you write:

My original motivation was to reduce the number of "sorts" per se at the meta-level (to just structures, well-formed formulas, symbols, and perhaps variable sequences). Some of the explicit mentions of languages in the statement of theorems seem to amount to forcing things to "type check" and I was curious if there was an alternative to "protecting" $\models$ so it's never consulted out of contract.

You could certainly do this. But as a general "design philosophy", I think it's better to have a stronger typing system at the meta-level, i.e., making it harder for expressions to type check. Type errors are generally easier to detect and fix than other kinds of errors. From this point of view, requiring $M$ and $\varphi$ to be a structure and a sentence in the same language $L$ before $M\models \varphi$ makes sense is actually "protecting" $\models$ against being used in meaningless statements. For example, if $G$ is a group and $\varphi$ is a sentence in the language of graphs, I would rather have $G\models \varphi$ be obviously meaningless (so that we aren't even allowed to write it down), instead of having some arbitrary default truth value (you suggest false in the question), which might be misleading later in a proof. How? Well, it's a bit contrived, but maybe I note that $G\not\models \varphi$, and then I conclude (erroneously) that $G\models \lnot \varphi$...
By analogy, we could define $\frac{1}{0}$ to have value $0$. Then we wouldn't have to do all that annoying checking that the denominator is non-zero when we use division in our calculations. The downside is that identities like $\frac{ab}{b} = a$ break down. So we have to check the denominator is non-zero at some point anyway (either when we write down the expression or when we use the identity), and psychologically I think the first choice is "safer" - it's easier to remember to do the check when you first write down the expression.
A stronger type system is also usually more elegant: The "checks" are all in the definitions, rather than being repeated over and over in the statements of results. And we don't have to choose ad hoc default values (like false or 0 in the two examples) for expressions that should really just not make any sense.
