I did not take the time to read all aswers in detail ... but I was amused.

There was a similar controversy in the sixties and early seventies : can high level languages be compiled to produce code as efficient as the machine code, well, say assembly code, produced manually by a programmer. Everyoone knows a programmer is much smarter than any program and can come up with very smart optimisation  (thinking actually mostly of what is now called peephole optimization).

There was even a concept of code expansion : the size of the code produced by a compiler to the size of code for the same program produced by a good programmer
(as if there had been too many of these :-). Of course the idea was that this ratio was always greater than 1.  The languages of the time were Cobol and Fortran 4, or Algol 60 for the intellectuals. I believe Lisp was not considered.

Well there were some rumors that someone had produced a compiler that could sometimes get an expansion ratio of 1  ...  until it simply became the rule that compiled code was much better than hand written code (and more reliable too).
People were worried about code size in those times (small memories) but the same goes for speed, or energie consumption.  I will not go into the reasons.

Weird features, dynamic features of a language do not matter.  What matters is how they are used, whether they are used. Performance, in whatever unit (code size, speed, energy, ...) is often dependent on very small parts of programs.
Hence there is a good chance that facilities that give expressive power will not really get in the way. With good programming practice, advanced facilities are used only in a disciplined way, to imagine new structures (that was the lisp lesson).

The fact that a language does not have static typing has never meant that programs written in that language are not statically typed. On the other hand it might be that the type system a program uses is not yet sufficiently formalized for a type checker to exist now.

In many cases, as it was before, human time and competence is scarcer than computing power.

The real problem of the future will be to evolve our languages to integrate new knowledge, new programming forms, without having to rewrite all the legacy software that is still used.

If you look at mathematics, it is a very large body of knowledge. The languages used to express it, notations and concepts has evolved over the centuries. It is easy to write old theorems with the new concepts. We do adapt the main proofs, but do not bother for lots of results.

But in the case of programming, we might have to rewrite all the proofs from scratch (programs are proofs). It may be that what we really need is very high level and evolvable programming.  Optimizer designers will be happy to follow.