Fix bug where interpolations were unnecessarily resolved during merge.

news/431.bugfix

@@ -0,0 +1 @@
+Fix bug where interpolations were unnecessarily resolved during merge

omegaconf/basecontainer.py

@@ -281,8 +281,11 @@ def _map_merge(dest: "BaseContainer", src: "BaseContainer") -> None:
         assert isinstance(src, DictConfig)
         src_type = src._metadata.object_type
 
+        if src._is_interpolation():
+            dest._set_value(src._value())
+            return
         # if source DictConfig is missing set the DictConfig one to be missing too.
-        if src._is_missing():
+        if src._is_missing(throw_on_resolution_failure=False):
             dest._set_value("???")
             return
         dest._validate_merge(key=None, value=src)
@@ -298,7 +301,7 @@ def expand(node: Container) -> None:
                 else:
                     node._set_value(type_)
 
-        if dest._is_missing():
+        if dest._is_interpolation() or dest._is_missing():
             expand(dest)
 
         for key, src_value in src.items_ex(resolve=False):
@@ -387,12 +390,11 @@ def _merge_with(
             if isinstance(self, DictConfig) and isinstance(other, DictConfig):
                 BaseContainer._map_merge(self, other)
             elif isinstance(self, ListConfig) and isinstance(other, ListConfig):
-                if self._is_none() or self._is_missing() or self._is_interpolation():
-                    self.__dict__["_content"] = []
-                else:
-                    self.__dict__["_content"].clear()
+                self.__dict__["_content"] = []
 
-                if other._is_missing():
+                if other._is_interpolation():
+                    self._set_value(other)
+                elif other._is_missing():
                     self._set_value("???")
                 elif other._is_none():
                     self._set_value(None)
@@ -575,9 +577,12 @@ def _item_eq(
     def _is_none(self) -> bool:
         return self.__dict__["_content"] is None
 
-    def _is_missing(self) -> bool:
+    def _is_missing(self, throw_on_resolution_failure: bool = True) -> bool:
         try:
-            self._dereference_node(throw_on_missing=True)
+            self._dereference_node(
+                throw_on_resolution_failure=throw_on_resolution_failure,
+                throw_on_missing=True,
+            )
             return False
         except MissingMandatoryValue:
             ret = True

omegaconf/dictconfig.py

@@ -445,7 +445,7 @@ def pop(self, key: Union[str, Enum], default: Any = DEFAULT_VALUE_MARKER) -> Any
             self._format_and_raise(key=key, value=None, cause=e)
 
     def keys(self) -> Any:
-        if self._is_missing() or self._is_interpolation() or self._is_none():
+        if self._is_interpolation() or self._is_missing() or self._is_none():
             return list()
         return self.__dict__["_content"].keys()
 

omegaconf/omegaconf.py

@@ -563,6 +563,8 @@ def _get_obj_type(c: Any) -> Optional[Type[Any]]:
         elif isinstance(c, DictConfig):
             if c._is_none():
                 return None
+            elif c._is_interpolation():
+                return None
             elif c._is_missing():
                 return None
             else:

tests/__init__.py

@@ -154,3 +154,13 @@ class SubscriptedList:
 @dataclass
 class SubscriptedDict:
     dict: Dict[str, int] = field(default_factory=lambda: {"foo": 4})
+
+
+@dataclass
+class InterpolationList:
+    list: List[float] = II("optimization.lr")
+
+
+@dataclass
+class InterpolationDict:
+    dict: Dict[str, int] = II("optimization.lr")

tests/test_merge.py

@@ -23,6 +23,8 @@
     ConfWithMissingDict,
     Group,
     IllegalType,
+    InterpolationDict,
+    InterpolationList,
     MissingDict,
     MissingList,
     Package,
@@ -484,3 +486,46 @@ def test_merge_allow_objects() -> None:
     cfg._set_flag("allow_objects", True)
     ret = OmegaConf.merge(cfg, {"foo": iv})
     assert ret == {"a": 10, "foo": iv}
+
+
+@pytest.mark.parametrize(  # type:ignore
+    "dst, other, expected, node, check_missing",
+    [
+        (
+            OmegaConf.structured(InterpolationList),
+            OmegaConf.create({"list": [0.1]}),
+            {"list": [0.1]},
+            "list",
+            False,
+        ),
+        (
+            OmegaConf.structured(InterpolationDict),
+            OmegaConf.create({"dict": {"a": 4}}),
+            {"dict": {"a": 4}},
+            "dict",
+            False,
+        ),
+        (
+            OmegaConf.structured(InterpolationDict),
+            OmegaConf.structured(InterpolationDict),
+            None,
+            "dict",
+            True,
+        ),
+        (
+            OmegaConf.structured(InterpolationList),
+            OmegaConf.structured(InterpolationList),
+            None,
+            "list",
+            True,
+        ),
+    ],
+)
+def test_merge_with_interpolation(
+    dst: Any, other: Any, expected: Any, node: Any, check_missing: bool
+) -> None:
+    res = OmegaConf.merge(dst, other)
+    if check_missing:
+        OmegaConf.is_missing(res, node)
+    else:
+        assert res == expected