tweak comments

esphome/components/cover/cover.cpp

@@ -22,11 +22,17 @@ const LogString *cover_command_to_str(float pos) {
     return LOG_STR("UNKNOWN");
   }
 }
-// Cover operation strings indexed by CoverOperation enum (0-2): IDLE, OPENING, CLOSING, plus UNKNOWN
-PROGMEM_STRING_TABLE(CoverOperationStrings, "IDLE", "OPENING", "CLOSING", "UNKNOWN");
-
 const LogString *cover_operation_to_str(CoverOperation op) {
-  return CoverOperationStrings::get_log_str(static_cast<uint8_t>(op), CoverOperationStrings::LAST_INDEX);
+  switch (op) {
+    case COVER_OPERATION_IDLE:
+      return LOG_STR("IDLE");
+    case COVER_OPERATION_OPENING:
+      return LOG_STR("OPENING");
+    case COVER_OPERATION_CLOSING:
+      return LOG_STR("CLOSING");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 Cover::Cover() : position{COVER_OPEN} {}

esphome/components/esp32/__init__.py

@@ -124,10 +124,14 @@ COMPILER_OPTIMIZATIONS = {
 # - "sdmmc": driver -> esp_driver_sdmmc -> sdmmc dependency chain
 DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "cmock",  # Unit testing mock framework - ESPHome doesn't use IDF's testing
+    "driver",  # Legacy driver shim - only needed by esp32_touch, esp32_can for legacy headers
     "esp_adc",  # ADC driver - only needed by adc component
+    "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
     "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
+    "esp_driver_mcpwm",  # MCPWM driver - ESPHome doesn't use motor control PWM
     "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
     "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
+    "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
     "esp_eth",  # Ethernet driver - only needed by ethernet component
     "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
     "esp_http_client",  # HTTP client - only needed by http_request component
@@ -138,9 +142,11 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "espcoredump",  # Core dump support - ESPHome has its own debug component
     "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
     "mqtt",  # ESP-IDF MQTT library - ESPHome has its own MQTT implementation
+    "openthread",  # Thread protocol - only needed by openthread component
     "perfmon",  # Xtensa performance monitor - ESPHome has its own debug component
     "protocomm",  # Protocol communication for provisioning - unused by ESPHome
     "spiffs",  # SPIFFS filesystem - ESPHome doesn't use filesystem storage (IDF only)
+    "ulp",  # ULP coprocessor - not currently used by any ESPHome component
     "unity",  # Unit testing framework - ESPHome doesn't use IDF's testing
     "wear_levelling",  # Flash wear levelling for fatfs - unused since fatfs unused
     "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation

esphome/components/esp32_can/canbus.py

@@ -15,6 +15,7 @@ from esphome.components.esp32 import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
     get_esp32_variant,
+    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -121,6 +122,10 @@ def get_default_tx_enqueue_timeout(bit_rate):
 
 
 async def to_code(config):
+    # Legacy driver component provides driver/twai.h header
+    include_builtin_idf_component("driver")
+    # Also enable esp_driver_twai for future migration to new API
+    include_builtin_idf_component("esp_driver_twai")
     var = cg.new_Pvariable(config[CONF_ID])
     await canbus.register_canbus(var, config)
 

esphome/components/esp32_dac/output.py

@@ -1,7 +1,12 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import output
-from esphome.components.esp32 import VARIANT_ESP32, VARIANT_ESP32S2, get_esp32_variant
+from esphome.components.esp32 import (
+    VARIANT_ESP32,
+    VARIANT_ESP32S2,
+    get_esp32_variant,
+    include_builtin_idf_component,
+)
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_NUMBER, CONF_PIN
 
@@ -38,6 +43,7 @@ CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
 
 
 async def to_code(config):
+    include_builtin_idf_component("esp_driver_dac")
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await output.register_output(var, config)

esphome/components/esp32_touch/__init__.py

@@ -269,6 +269,8 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     # Re-enable ESP-IDF's touch sensor driver (excluded by default to save compile time)
     include_builtin_idf_component("esp_driver_touch_sens")
+    # Legacy driver component provides driver/touch_sensor.h header
+    include_builtin_idf_component("driver")
 
     touch = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(touch, config)

esphome/components/light/light_json_schema.cpp

@@ -9,19 +9,32 @@ namespace esphome::light {
 
 // See https://www.home-assistant.io/integrations/light.mqtt/#json-schema for documentation on the schema
 
-// Color mode JSON strings - packed into flash with compile-time generated offsets.
-// Indexed by ColorModeBitPolicy bit index (1-9), so index 0 maps to bit 1 ("onoff").
-PROGMEM_STRING_TABLE(ColorModeStrings, "onoff", "brightness", "white", "color_temp", "cwww", "rgb", "rgbw", "rgbct",
-                     "rgbww");
-
-// Get JSON string for color mode. Returns nullptr for UNKNOWN (bit 0).
-// Returns ProgmemStr so ArduinoJson knows to handle PROGMEM strings on ESP8266.
+// Get JSON string for color mode.
+// ColorMode enum values are sparse bitmasks (0, 1, 3, 7, 11, 19, 35, 39, 47, 51) which would
+// generate a large jump table. Converting to bit index (0-9) allows a compact switch.
 static ProgmemStr get_color_mode_json_str(ColorMode mode) {
-  unsigned bit = ColorModeBitPolicy::to_bit(mode);
-  if (bit == 0)
-    return nullptr;
-  // bit is 1-9 for valid modes, so bit-1 is always valid (0-8). LAST_INDEX fallback never used.
-  return ColorModeStrings::get_progmem_str(bit - 1, ColorModeStrings::LAST_INDEX);
+  switch (ColorModeBitPolicy::to_bit(mode)) {
+    case 1:
+      return ESPHOME_F("onoff");
+    case 2:
+      return ESPHOME_F("brightness");
+    case 3:
+      return ESPHOME_F("white");
+    case 4:
+      return ESPHOME_F("color_temp");
+    case 5:
+      return ESPHOME_F("cwww");
+    case 6:
+      return ESPHOME_F("rgb");
+    case 7:
+      return ESPHOME_F("rgbw");
+    case 8:
+      return ESPHOME_F("rgbct");
+    case 9:
+      return ESPHOME_F("rgbww");
+    default:
+      return nullptr;
+  }
 }
 
 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {

esphome/components/logger/logger.cpp

@@ -4,7 +4,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome::logger {
 
@@ -292,20 +291,34 @@ UARTSelection Logger::get_uart() const { return this->uart_; }
 
 float Logger::get_setup_priority() const { return setup_priority::BUS + 500.0f; }
 
-// Log level strings - packed into flash on ESP8266, indexed by log level (0-7)
-PROGMEM_STRING_TABLE(LogLevelStrings, "NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE");
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+// ESP8266: PSTR() cannot be used in array initializers, so we need to declare
+// each string separately as a global constant first
+static const char LOG_LEVEL_NONE[] PROGMEM = "NONE";
+static const char LOG_LEVEL_ERROR[] PROGMEM = "ERROR";
+static const char LOG_LEVEL_WARN[] PROGMEM = "WARN";
+static const char LOG_LEVEL_INFO[] PROGMEM = "INFO";
+static const char LOG_LEVEL_CONFIG[] PROGMEM = "CONFIG";
+static const char LOG_LEVEL_DEBUG[] PROGMEM = "DEBUG";
+static const char LOG_LEVEL_VERBOSE[] PROGMEM = "VERBOSE";
+static const char LOG_LEVEL_VERY_VERBOSE[] PROGMEM = "VERY_VERBOSE";
 
-static const LogString *get_log_level_str(uint8_t level) {
-  return LogLevelStrings::get_log_str(level, LogLevelStrings::LAST_INDEX);
-}
+static const LogString *const LOG_LEVELS[] = {
+    reinterpret_cast<const LogString *>(LOG_LEVEL_NONE),    reinterpret_cast<const LogString *>(LOG_LEVEL_ERROR),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_WARN),    reinterpret_cast<const LogString *>(LOG_LEVEL_INFO),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_CONFIG),  reinterpret_cast<const LogString *>(LOG_LEVEL_DEBUG),
+    reinterpret_cast<const LogString *>(LOG_LEVEL_VERBOSE), reinterpret_cast<const LogString *>(LOG_LEVEL_VERY_VERBOSE),
+};
+#else
+static const char *const LOG_LEVELS[] = {"NONE", "ERROR", "WARN", "INFO", "CONFIG", "DEBUG", "VERBOSE", "VERY_VERBOSE"};
+#endif
 
 void Logger::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Logger:\n"
                 "  Max Level: %s\n"
                 "  Initial Level: %s",
-                LOG_STR_ARG(get_log_level_str(ESPHOME_LOG_LEVEL)),
-                LOG_STR_ARG(get_log_level_str(this->current_level_)));
+                LOG_STR_ARG(LOG_LEVELS[ESPHOME_LOG_LEVEL]), LOG_STR_ARG(LOG_LEVELS[this->current_level_]));
 #ifndef USE_HOST
   ESP_LOGCONFIG(TAG,
                 "  Log Baud Rate: %" PRIu32 "\n"
@@ -324,7 +337,7 @@ void Logger::dump_config() {
 
 #ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
   for (auto &it : this->log_levels_) {
-    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first, LOG_STR_ARG(get_log_level_str(it.second)));
+    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first, LOG_STR_ARG(LOG_LEVELS[it.second]));
   }
 #endif
 }
@@ -332,8 +345,7 @@ void Logger::dump_config() {
 void Logger::set_log_level(uint8_t level) {
   if (level > ESPHOME_LOG_LEVEL) {
     level = ESPHOME_LOG_LEVEL;
-    ESP_LOGW(TAG, "Cannot set log level higher than pre-compiled %s",
-             LOG_STR_ARG(get_log_level_str(ESPHOME_LOG_LEVEL)));
+    ESP_LOGW(TAG, "Cannot set log level higher than pre-compiled %s", LOG_STR_ARG(LOG_LEVELS[ESPHOME_LOG_LEVEL]));
   }
   this->current_level_ = level;
 #ifdef USE_LOGGER_LEVEL_LISTENERS

esphome/components/openthread/__init__.py

@@ -4,6 +4,7 @@ from esphome.components.esp32 import (
     VARIANT_ESP32C6,
     VARIANT_ESP32H2,
     add_idf_sdkconfig_option,
+    include_builtin_idf_component,
     only_on_variant,
     require_vfs_select,
 )
@@ -172,6 +173,9 @@ FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
+    # Re-enable openthread IDF component (excluded by default)
+    include_builtin_idf_component("openthread")
+
     cg.add_define("USE_OPENTHREAD")
 
     # OpenThread SRP needs access to mDNS services after setup

esphome/components/sensor/sensor.cpp

@@ -2,7 +2,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome::sensor {
 
@@ -31,13 +30,20 @@ void log_sensor(const char *tag, const char *prefix, const char *type, Sensor *o
   }
 }
 
-// State class strings indexed by StateClass enum (0-4): NONE, MEASUREMENT, TOTAL_INCREASING, TOTAL, MEASUREMENT_ANGLE
-PROGMEM_STRING_TABLE(StateClassStrings, "", "measurement", "total_increasing", "total", "measurement_angle");
-static_assert(StateClassStrings::COUNT == STATE_CLASS_LAST + 1, "StateClassStrings must match StateClass enum");
-
 const LogString *state_class_to_string(StateClass state_class) {
-  // Fallback to index 0 (empty string for STATE_CLASS_NONE) if out of range
-  return StateClassStrings::get_log_str(static_cast<uint8_t>(state_class), 0);
+  switch (state_class) {
+    case STATE_CLASS_MEASUREMENT:
+      return LOG_STR("measurement");
+    case STATE_CLASS_TOTAL_INCREASING:
+      return LOG_STR("total_increasing");
+    case STATE_CLASS_TOTAL:
+      return LOG_STR("total");
+    case STATE_CLASS_MEASUREMENT_ANGLE:
+      return LOG_STR("measurement_angle");
+    case STATE_CLASS_NONE:
+    default:
+      return LOG_STR("");
+  }
 }
 
 Sensor::Sensor() : state(NAN), raw_state(NAN) {}

esphome/components/sensor/sensor.h

@@ -32,7 +32,6 @@ enum StateClass : uint8_t {
   STATE_CLASS_TOTAL = 3,
   STATE_CLASS_MEASUREMENT_ANGLE = 4
 };
-constexpr uint8_t STATE_CLASS_LAST = static_cast<uint8_t>(STATE_CLASS_MEASUREMENT_ANGLE);
 
 const LogString *state_class_to_string(StateClass state_class);
 

esphome/components/udp/__init__.py

@@ -12,8 +12,8 @@ from esphome.components.packet_transport import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
-from esphome.core import ID, Lambda
-from esphome.cpp_generator import ExpressionStatement, MockObj
+from esphome.core import ID
+from esphome.cpp_generator import literal
 
 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -24,6 +24,8 @@ udp_ns = cg.esphome_ns.namespace("udp")
 UDPComponent = udp_ns.class_("UDPComponent", cg.Component)
 UDPWriteAction = udp_ns.class_("UDPWriteAction", automation.Action)
 trigger_args = cg.std_vector.template(cg.uint8)
+trigger_argname = "data"
+trigger_argtype = [(trigger_args, trigger_argname)]
 
 CONF_ADDRESSES = "addresses"
 CONF_LISTEN_ADDRESS = "listen_address"
@@ -111,13 +113,14 @@ async def to_code(config):
     cg.add(var.set_addresses([str(addr) for addr in config[CONF_ADDRESSES]]))
     if on_receive := config.get(CONF_ON_RECEIVE):
         on_receive = on_receive[0]
-        trigger = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
+        trigger_id = cg.new_Pvariable(on_receive[CONF_TRIGGER_ID])
         trigger = await automation.build_automation(
-            trigger, [(trigger_args, "data")], on_receive
+            trigger_id, trigger_argtype, on_receive
         )
-        trigger = Lambda(str(ExpressionStatement(trigger.trigger(MockObj("data")))))
-        trigger = await cg.process_lambda(trigger, [(trigger_args, "data")])
-        cg.add(var.add_listener(trigger))
+        trigger_lambda = await cg.process_lambda(
+            trigger.trigger(literal(trigger_argname)), trigger_argtype
+        )
+        cg.add(var.add_listener(trigger_lambda))
         cg.add(var.set_should_listen())
 
 

esphome/components/valve/valve.cpp

@@ -23,11 +23,17 @@ const LogString *valve_command_to_str(float pos) {
     return LOG_STR("UNKNOWN");
   }
 }
-// Valve operation strings indexed by ValveOperation enum (0-2): IDLE, OPENING, CLOSING, plus UNKNOWN
-PROGMEM_STRING_TABLE(ValveOperationStrings, "IDLE", "OPENING", "CLOSING", "UNKNOWN");
-
 const LogString *valve_operation_to_str(ValveOperation op) {
-  return ValveOperationStrings::get_log_str(static_cast<uint8_t>(op), ValveOperationStrings::LAST_INDEX);
+  switch (op) {
+    case VALVE_OPERATION_IDLE:
+      return LOG_STR("IDLE");
+    case VALVE_OPERATION_OPENING:
+      return LOG_STR("OPENING");
+    case VALVE_OPERATION_CLOSING:
+      return LOG_STR("CLOSING");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 Valve::Valve() : position{VALVE_OPEN} {}

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -36,7 +36,6 @@ extern "C" {
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include "esphome/core/util.h"
 
 namespace esphome::wifi {
@@ -399,22 +398,36 @@ class WiFiMockClass : public ESP8266WiFiGenericClass {
   static void _event_callback(void *event) { ESP8266WiFiGenericClass::_eventCallback(event); }  // NOLINT
 };
 
-// Auth mode strings indexed by AUTH_* constants (0-4), with UNKNOWN at last index
-// Static asserts verify the SDK constants are contiguous as expected
-static_assert(AUTH_OPEN == 0 && AUTH_WEP == 1 && AUTH_WPA_PSK == 2 && AUTH_WPA2_PSK == 3 && AUTH_WPA_WPA2_PSK == 4,
-              "AUTH_* constants are not contiguous");
-PROGMEM_STRING_TABLE(AuthModeStrings, "OPEN", "WEP", "WPA PSK", "WPA2 PSK", "WPA/WPA2 PSK", "UNKNOWN");
-
 const LogString *get_auth_mode_str(uint8_t mode) {
-  return AuthModeStrings::get_log_str(mode, AuthModeStrings::LAST_INDEX);
+  switch (mode) {
+    case AUTH_OPEN:
+      return LOG_STR("OPEN");
+    case AUTH_WEP:
+      return LOG_STR("WEP");
+    case AUTH_WPA_PSK:
+      return LOG_STR("WPA PSK");
+    case AUTH_WPA2_PSK:
+      return LOG_STR("WPA2 PSK");
+    case AUTH_WPA_WPA2_PSK:
+      return LOG_STR("WPA/WPA2 PSK");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
+const LogString *get_op_mode_str(uint8_t mode) {
+  switch (mode) {
+    case WIFI_OFF:
+      return LOG_STR("OFF");
+    case WIFI_STA:
+      return LOG_STR("STA");
+    case WIFI_AP:
+      return LOG_STR("AP");
+    case WIFI_AP_STA:
+      return LOG_STR("AP+STA");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
-
-// WiFi op mode strings indexed by WIFI_* constants (0-3), with UNKNOWN at last index
-static_assert(WIFI_OFF == 0 && WIFI_STA == 1 && WIFI_AP == 2 && WIFI_AP_STA == 3,
-              "WIFI_* op mode constants are not contiguous");
-PROGMEM_STRING_TABLE(OpModeStrings, "OFF", "STA", "AP", "AP+STA", "UNKNOWN");
-
-const LogString *get_op_mode_str(uint8_t mode) { return OpModeStrings::get_log_str(mode, OpModeStrings::LAST_INDEX); }
 
 const LogString *get_disconnect_reason_str(uint8_t reason) {
   /* If this were one big switch statement, GCC would generate a lookup table for it. However, the values of the

esphome/core/__init__.py

@@ -278,9 +278,13 @@ LAMBDA_PROG = re.compile(r"\bid\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)(\.?)")
 
 class Lambda:
     def __init__(self, value):
+        from esphome.cpp_generator import Expression, statement
+
         # pylint: disable=protected-access
         if isinstance(value, Lambda):
             self._value = value._value
+        elif isinstance(value, Expression):
+            self._value = str(statement(value))
         else:
             self._value = value
         self._parts = None

esphome/core/progmem.h

@@ -1,11 +1,5 @@
 #pragma once
 
-#include <array>
-#include <cstddef>
-#include <cstdint>
-
-#include "esphome/core/hal.h"  // For PROGMEM definition
-
 // Platform-agnostic macros for PROGMEM string handling
 // On ESP8266/Arduino: Use Arduino's F() macro for PROGMEM strings
 // On other platforms: Use plain strings (no PROGMEM)
@@ -38,80 +32,3 @@ using ProgmemStr = const __FlashStringHelper *;
 // Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
 using ProgmemStr = const char *;
 #endif
-
-namespace esphome {
-
-/// Helper for C++20 string literal template arguments
-template<size_t N> struct FixedString {
-  char data[N]{};
-  constexpr FixedString(const char (&str)[N]) {
-    for (size_t i = 0; i < N; ++i)
-      data[i] = str[i];
-  }
-  constexpr size_t size() const { return N - 1; }  // exclude null terminator
-};
-
-/// Compile-time string table that packs strings into a single blob with offset lookup.
-/// Use PROGMEM_STRING_TABLE macro to instantiate with proper flash placement on ESP8266.
-///
-/// Example:
-///   PROGMEM_STRING_TABLE(MyStrings, "foo", "bar", "baz");
-///   ProgmemStr str = MyStrings::get_progmem_str(idx, MyStrings::LAST_INDEX);  // For ArduinoJson
-///   const LogString *log_str = MyStrings::get_log_str(idx, MyStrings::LAST_INDEX);  // For logging
-///
-template<FixedString... Strs> struct ProgmemStringTable {
-  static constexpr size_t COUNT = sizeof...(Strs);
-  static constexpr size_t BLOB_SIZE = (0 + ... + (Strs.size() + 1));
-
-  /// Generate packed string blob at compile time
-  static constexpr auto make_blob() {
-    std::array<char, BLOB_SIZE> result{};
-    size_t pos = 0;
-    auto copy = [&](const auto &str) {
-      for (size_t i = 0; i <= str.size(); ++i)
-        result[pos++] = str.data[i];
-    };
-    (copy(Strs), ...);
-    return result;
-  }
-
-  /// Generate offset table at compile time (uint8_t limits blob to 255 bytes)
-  static constexpr auto make_offsets() {
-    static_assert(COUNT > 0, "PROGMEM_STRING_TABLE must contain at least one string");
-    static_assert(COUNT <= 255, "PROGMEM_STRING_TABLE supports at most 255 strings with uint8_t indices");
-    static_assert(BLOB_SIZE <= 255, "PROGMEM_STRING_TABLE blob exceeds 255 bytes; use fewer/shorter strings");
-    std::array<uint8_t, COUNT> result{};
-    size_t pos = 0, idx = 0;
-    ((result[idx++] = static_cast<uint8_t>(pos), pos += Strs.size() + 1), ...);
-    return result;
-  }
-};
-
-// Forward declaration for LogString (defined in log.h)
-struct LogString;
-
-/// Instantiate a ProgmemStringTable with PROGMEM storage.
-/// Creates: Name::get_progmem_str(idx, fallback), Name::get_log_str(idx, fallback)
-/// If idx >= COUNT, returns string at fallback. Use LAST_INDEX for common patterns.
-#define PROGMEM_STRING_TABLE(Name, ...) \
-  struct Name { \
-    using Table = ::esphome::ProgmemStringTable<__VA_ARGS__>; \
-    static constexpr size_t COUNT = Table::COUNT; \
-    static constexpr uint8_t LAST_INDEX = COUNT - 1; \
-    static constexpr size_t BLOB_SIZE = Table::BLOB_SIZE; \
-    static constexpr auto BLOB PROGMEM = Table::make_blob(); \
-    static constexpr auto OFFSETS PROGMEM = Table::make_offsets(); \
-    static const char *get_(uint8_t idx, uint8_t fallback) { \
-      if (idx >= COUNT) \
-        idx = fallback; \
-      return &BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]; \
-    } \
-    static ::ProgmemStr get_progmem_str(uint8_t idx, uint8_t fallback) { \
-      return reinterpret_cast<::ProgmemStr>(get_(idx, fallback)); \
-    } \
-    static const ::esphome::LogString *get_log_str(uint8_t idx, uint8_t fallback) { \
-      return reinterpret_cast<const ::esphome::LogString *>(get_(idx, fallback)); \
-    } \
-  }
-
-}  // namespace esphome

esphome/cpp_generator.py

@@ -462,6 +462,16 @@ def statement(expression: Expression | Statement) -> Statement:
     return ExpressionStatement(expression)
 
 
+def literal(name: str) -> "MockObj":
+    """Create a literal name that will appear in the generated code
+    not surrounded by quotes.
+
+    :param name: The name of the literal.
+    :return: The literal as a MockObj.
+    """
+    return MockObj(name, "")
+
+
 def variable(
     id_: ID, rhs: SafeExpType, type_: "MockObj" = None, register=True
 ) -> "MockObj":
@@ -665,7 +675,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
 
 
 async def process_lambda(
-    value: Lambda,
+    value: Lambda | Expression,
     parameters: TemplateArgsType,
     capture: str = "",
     return_type: SafeExpType = None,
@@ -689,6 +699,14 @@ async def process_lambda(
 
     if value is None:
         return None
+    # Inadvertently passing a malformed parameters value will lead to the build process mysteriously hanging at the
+    # "Generating C++ source..." stage, so check here to save the developer's hair.
+    assert isinstance(parameters, list) and all(
+        isinstance(p, tuple) and len(p) == 2 for p in parameters
+    )
+    if isinstance(value, Expression):
+        value = Lambda(value)
+
     parts = value.parts[:]
     for i, id in enumerate(value.requires_ids):
         full_id, var = await get_variable_with_full_id(id)

tests/unit_tests/test_cpp_generator.py

@@ -347,3 +347,280 @@ class TestMockObj:
         assert isinstance(actual, cg.MockObj)
         assert actual.base == "foo.eek"
         assert actual.op == "."
+
+
+class TestStatementFunction:
+    """Tests for the statement() function."""
+
+    def test_statement__expression_converted_to_statement(self):
+        """Test that expressions are converted to ExpressionStatement."""
+        expr = cg.RawExpression("foo()")
+        result = cg.statement(expr)
+
+        assert isinstance(result, cg.ExpressionStatement)
+        assert str(result) == "foo();"
+
+    def test_statement__statement_unchanged(self):
+        """Test that statements are returned unchanged."""
+        stmt = cg.RawStatement("foo()")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "foo()"
+
+    def test_statement__expression_statement_unchanged(self):
+        """Test that ExpressionStatement is returned unchanged."""
+        stmt = cg.ExpressionStatement(42)
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "42;"
+
+    def test_statement__line_comment_unchanged(self):
+        """Test that LineComment is returned unchanged."""
+        stmt = cg.LineComment("This is a comment")
+        result = cg.statement(stmt)
+
+        assert result is stmt
+        assert str(result) == "// This is a comment"
+
+
+class TestLiteralFunction:
+    """Tests for the literal() function."""
+
+    def test_literal__creates_mockobj(self):
+        """Test that literal() creates a MockObj."""
+        result = cg.literal("MY_CONSTANT")
+
+        assert isinstance(result, cg.MockObj)
+        assert result.base == "MY_CONSTANT"
+        assert result.op == ""
+
+    def test_literal__string_representation(self):
+        """Test that literal names appear unquoted in generated code."""
+        result = cg.literal("nullptr")
+
+        assert str(result) == "nullptr"
+
+    def test_literal__can_be_used_in_expressions(self):
+        """Test that literals can be used as part of larger expressions."""
+        null_lit = cg.literal("nullptr")
+        expr = cg.CallExpression(cg.RawExpression("my_func"), null_lit)
+
+        assert str(expr) == "my_func(nullptr)"
+
+    def test_literal__common_cpp_literals(self):
+        """Test common C++ literal values."""
+        test_cases = [
+            ("nullptr", "nullptr"),
+            ("true", "true"),
+            ("false", "false"),
+            ("NULL", "NULL"),
+            ("NAN", "NAN"),
+        ]
+
+        for name, expected in test_cases:
+            result = cg.literal(name)
+            assert str(result) == expected
+
+
+class TestLambdaConstructor:
+    """Tests for the Lambda class constructor in core/__init__.py."""
+
+    def test_lambda__from_string(self):
+        """Test Lambda constructor with string argument."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+
+        assert lambda_obj.value == "return x + 1;"
+        assert str(lambda_obj) == "return x + 1;"
+
+    def test_lambda__from_expression(self):
+        """Test Lambda constructor with Expression argument."""
+        from esphome.core import Lambda
+
+        expr = cg.RawExpression("x + 1")
+        lambda_obj = Lambda(expr)
+
+        # Expression should be converted to statement (with semicolon)
+        assert lambda_obj.value == "x + 1;"
+
+    def test_lambda__from_lambda(self):
+        """Test Lambda constructor with another Lambda argument."""
+        from esphome.core import Lambda
+
+        original = Lambda("return x + 1;")
+        copy = Lambda(original)
+
+        assert copy.value == original.value
+        assert copy.value == "return x + 1;"
+
+    def test_lambda__parts_parsing(self):
+        """Test that Lambda correctly parses parts with id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(my_sensor).state;")
+        parts = lambda_obj.parts
+
+        # Parts should be split by LAMBDA_PROG regex: text, id, op, text
+        assert len(parts) == 4
+        assert parts[0] == "return "
+        assert parts[1] == "my_sensor"
+        assert parts[2] == "."
+        assert parts[3] == "state;"
+
+    def test_lambda__requires_ids(self):
+        """Test that Lambda correctly extracts required IDs."""
+        from esphome.core import ID, Lambda
+
+        lambda_obj = Lambda("return id(sensor1).state + id(sensor2).value;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 2
+        assert all(isinstance(id_obj, ID) for id_obj in ids)
+        assert ids[0].id == "sensor1"
+        assert ids[1].id == "sensor2"
+
+    def test_lambda__no_ids(self):
+        """Test Lambda with no id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        ids = lambda_obj.requires_ids
+
+        assert len(ids) == 0
+
+    def test_lambda__comment_removal(self):
+        """Test that comments are removed when parsing parts."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return id(sensor).state; // Get sensor state")
+        parts = lambda_obj.parts
+
+        # Comment should be replaced with space, not affect parsing
+        assert "my_sensor" not in str(parts)
+
+    def test_lambda__multiline_string(self):
+        """Test Lambda with multiline string."""
+        from esphome.core import Lambda
+
+        code = """if (id(sensor).state > 0) {
+  return true;
+}
+return false;"""
+        lambda_obj = Lambda(code)
+
+        assert lambda_obj.value == code
+        assert "sensor" in [id_obj.id for id_obj in lambda_obj.requires_ids]
+
+
+@pytest.mark.asyncio
+class TestProcessLambda:
+    """Tests for the process_lambda() async function."""
+
+    async def test_process_lambda__none_value(self):
+        """Test that None returns None."""
+        result = await cg.process_lambda(None, [])
+
+        assert result is None
+
+    async def test_process_lambda__with_expression(self):
+        """Test process_lambda with Expression argument."""
+
+        expr = cg.RawExpression("return x + 1")
+        result = await cg.process_lambda(expr, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        assert "x + 1" in str(result)
+
+    async def test_process_lambda__simple_lambda_no_ids(self):
+        """Test process_lambda with simple Lambda without id() references."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")])
+
+        assert isinstance(result, cg.LambdaExpression)
+        # Should have parameter
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "return x + 1;" in lambda_str
+
+    async def test_process_lambda__with_return_type(self):
+        """Test process_lambda with return type specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x > 0;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], return_type=bool)
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "-> bool" in lambda_str
+
+    async def test_process_lambda__with_capture(self):
+        """Test process_lambda with capture specified."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return captured + x;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="captured")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[captured]" in lambda_str
+
+    async def test_process_lambda__empty_capture(self):
+        """Test process_lambda with empty capture (stateless lambda)."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + 1;")
+        result = await cg.process_lambda(lambda_obj, [(int, "x")], capture="")
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "[]" in lambda_str
+
+    async def test_process_lambda__no_parameters(self):
+        """Test process_lambda with no parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return 42;")
+        result = await cg.process_lambda(lambda_obj, [])
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        # Should have empty parameter list
+        assert "()" in lambda_str
+
+    async def test_process_lambda__multiple_parameters(self):
+        """Test process_lambda with multiple parameters."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x + y + z;")
+        result = await cg.process_lambda(
+            lambda_obj, [(int, "x"), (float, "y"), (bool, "z")]
+        )
+
+        assert isinstance(result, cg.LambdaExpression)
+        lambda_str = str(result)
+        assert "int32_t x" in lambda_str
+        assert "float y" in lambda_str
+        assert "bool z" in lambda_str
+
+    async def test_process_lambda__parameter_validation(self):
+        """Test that malformed parameters raise assertion error."""
+        from esphome.core import Lambda
+
+        lambda_obj = Lambda("return x;")
+
+        # Test invalid parameter format (not list of tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, "invalid")
+
+        # Test invalid tuple format (not 2-element tuples)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int, "x", "extra")])
+
+        # Test invalid tuple format (single element)
+        with pytest.raises(AssertionError):
+            await cg.process_lambda(lambda_obj, [(int,)])