What are the exact requirements of not requiring forward declarations everywhere?

Question

Some languages like C and C++ require defining the names before using them, though the definition could sometimes be only a header specifying something is a struct or function without the body. Some languages don't. And many interpreted languages are mixed, that you could refer to anything in the definition, but the code must be called after the referred entities are also defined completely.

What are the exact criteria for designing the syntax to make referring before definition possible? And is it possible to have a middle ground, that forward declarations are only required in the situations that it is absolutely necessary?

In the best case, function bodies are just strings, and definitions are scanned before evaluation, making this trivial. In the worst case, you could define new syntax in the code, which may change the position of the end of a function, making this obviously impossible. But where do they meet?

A special example is Bash, where functions are in the mixed way, as they are just called using their names as strings and there isn't a mechanism to track down where they are defined, but aliases must be defined before using in a function, because you could alias unpaired braces or other grouping constructs. It looks like a middle ground, but is greatly simplified because of the fact that Bash is not object oriented. In object oriented languages, object definitions may carry a syntax change from a class elsewhere.

Answer 1

Multi passes

Forward declarations are a specific requirement of one pass compilation process. So to not have to forward declare anything, your language is expected to have two or more passes on code or AST to resolve pending names.

C and C++ are special in this case because any previous typedef may change the parsing of the following expression. Languages with keywords to declare types and functions don't have this extra requirement.

Dynamic languages without type checking and dispatch based purely by names don't need more than one pass because any dispatch occurs by consulting what is basically a global dictionary of names.

But type checking languages, dynamic or static, will need more passes for any reference not declared before use.