Foreword:
To inline a function i.e. the act of inlining i.e. inline expansion is an optimization where a function call is replaced by duplicated set of instructions.
To declare an inline function is to declare to the linker that the function is to be treated differently than non-inline functions. Specifically, the one-definition-rule is different for inline functions. Inline functions are allowed to be defined in multiple translation units (and in fact required to be defined in all translation units where the function is odr-used). This is different from non-inline functions, which must be defined in exactly one translation unit. The inline keyword can be used the declare an inline function.
While inline declaration is named similarly to the inlining optimization, and while former can indirectly affect whether latter is possible, these two concepts are separate.
Now, to the answer.
If I want a function to be inlined, I have to use the inline keyword in the declaration.
You don't necessarily have to use the inline keyword. A call to a non-inline function can be expanded inline by the compiler if the function is defined in the same translation unit. Even that is not a requirement for a linktime optimizer which sees all translation units.
Example:
// a.cpp
void foo(){} // a non-inline function
inline void qux(){} // an inline function
void bar(){
foo(); // this call to a non-inline function can be expanded inline
// because the function is defined in the same TU
}
// b.cpp
void foo(); // the non-inline function must not be defined
// in multiple translation units
inline void qux(){} // the inline function can and must be defined
// in both translation units
void xeb(){
foo(); // this call to a non-inline function can not be expanded inline by
// the compiler because the function is not defined in the same TU
// the call can be expanded by a linker
qux(); // this call can be expanded by the compiler
// because the function is defined in the same TU
}
That said, linktime optimization isn't always an option, and function calls do happen across translation units, so inline definition is in some cases indeed necessary to allow inline expansion.
A pedantic point: A function can declared inline without the inline keyword (if it is a member function).
Why can't I just use inline when calling a function?
There just isn't such syntax in the language.
Note that the function would still have to be defined in the same translation unit or else it cannot be expanded inline by the compiler. Thus the function would still need to be declared inline if you wanted inline expansion in more than one translation unit.
I suspect that the reason why there is no syntax to force inline expansion is probably the same as why there is no way to select which branch of an if statement is the "default" branch which might have marginal effect on performance (the reasoning is just my guess in both cases): Humans are notoriously bad at optimization. I see no technical reason why such language feature couldn't be introduced. But I wouldn't expect such feature to be very useful.
