Q:

Why decltype isn't implicit? 

Why decltype can't be implicitly added to an expression when type was expected? 
template <class X, class Y, class Z>
auto foo(X x, Y y, Z z){
    std::vector<decltype(x+y*z)> values;  // valid in c++11/c++14
    //std::vector<x+y*z> values;            // invalid
    values.push_back(x+y*z);
    return values;                        // type deduced from expression - OK
}

In c++14 compilers will able to deduce function return type based on return expressions.  Why this can't be extended to any 'expression -> type' conversion? 
The same apply to declval, why I have to write:
std::vector<decltype(declval<X>() + declval<Y>() * declval<Z>())> values;

instead of:
std::vector<X+Y*Z> values;

A:

If implicit addition of decltype would be allowed, some very common templates would become ambiguous, or even impossible to express. 

Consider the following example :
struct tp 
{
    template<typename T>
    void foo() { cout << "Type parameter\n"; }   

    template<int Value>
    void foo() { cout << "Value parameter\n"; }   
};

int main() 
{
  const int x = 1;
  const int y = 2;
  const int z = 3;

  tp t1;
  t1.foo<x*y+z>();
  t1.foo<decltype(x*y+z)>(); // Oops !  different version of foo() 
  t1.foo<int>();

  return 0;
}

Output:

Value parameter
Type parameter
Type parameter

If decltype is implicitly added to t1.foo<x*y+z>();, the wrong version of foo() is called. 

C++ policy for expressing what you do, and avoid when possible any implicit work by the compiler is IMHO a very good thing.  It makes things easier to read, to understand, and to maintain. 
After all, decltype is only 8 letters

Live demo here. 