a couple of more test cases for variants of similar cases, and a fix for those

Author: johanandren

config/src/main/java/com/typesafe/config/impl/ConfigDelayedMerge.java

@@ -84,6 +84,18 @@ static ResolveResult<? extends AbstractConfigValue> resolveSubstitutions(Replace
         int count = 0;
         AbstractConfigValue merged = null;
         for (AbstractConfigValue end : stack) {
+            // Per the HOCON spec, a substitution hidden by a value that
+            // cannot be merged with it is never evaluated. Once the
+            // accumulated merged value ignores fallbacks, nothing below it
+            // in the stack can contribute, so skip it to avoid evaluating
+            // substitutions that cannot affect the result.
+            if (merged != null && merged.ignoresFallbacks()) {
+                if (ConfigImpl.traceSubstitutionsEnabled())
+                    ConfigImpl.trace(newContext.depth(),
+                            "merged ignores fallbacks, skipping remaining stack");
+                break;
+            }
+
             // the end value may or may not be resolved already
 
             ResolveSource sourceForEnd;

config/src/test/scala/com/typesafe/config/impl/ConfigSubstitutionTest.scala

@@ -1304,4 +1304,43 @@ class ConfigSubstitutionTest extends TestUtils {
         val resolvedViaSub = resolve(viaSub)
         assertEquals(parseObject("""{ a : { x : 1 } }"""), resolvedViaSub.getConfig("p").root)
     }
+
+    // Spec (HOCON.md): "If a substitution is hidden by a value that could not
+    // be merged with it (by a non-object value) then it is never evaluated and
+    // no error will be reported." The direct top-level case from the spec.
+    @Test
+    def substitutionHiddenByLiteralNonObjectIsNotEvaluated() {
+        val obj = parseObject("""
+            foo: ${does-not-exist}
+            foo: 42
+        """)
+        val resolved = resolve(obj)
+        assertEquals(42, resolved.getInt("foo"))
+    }
+
+    // Variant of #838: an object containing a substitution is hidden by a
+    // literal non-object. The object cannot merge with 42, so the enclosed
+    // substitution must not be evaluated.
+    @Test
+    def substitutionInsideObjectHiddenByLiteralNonObjectIsNotEvaluated() {
+        val obj = parseObject("""
+            p: { a : ${does-not-exist} }
+            p: 42
+        """)
+        val resolved = resolve(obj)
+        assertEquals(42, resolved.getInt("p"))
+    }
+
+    // Variant of #838: an object containing a substitution is hidden by a
+    // substitution that resolves to a non-object. Same spec intent applies.
+    @Test
+    def substitutionInsideObjectHiddenByNonObjectFromSubstitutionIsNotEvaluated() {
+        val obj = parseObject("""
+            p: { a : ${does-not-exist} }
+            p: ${z}
+            z: 42
+        """)
+        val resolved = resolve(obj)
+        assertEquals(42, resolved.getInt("p"))
+    }
 }