cty: Known result special cases for Multiply, And, and Or

Now that we're in the business of trying to produce known values from
operations on unknown inputs where possible, these are some simple cases
that hold regardless of the range/refinements of the unknown operands and
can help take a particular unknown result out of consideration when
evaluating a broader expression.

cty/value_ops.go

@@ -647,6 +647,11 @@ func (val Value) Multiply(other Value) Value {
 	}
 
 	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		// If either value is exactly zero then the result must either be
+		// zero or an error.
+		if val == Zero || other == Zero {
+			return Zero
+		}
 		shortCircuit = forceShortCircuitType(shortCircuit, Number)
 		ret := shortCircuit.RefineWith(numericRangeArithmetic(Value.Multiply, val.Range(), other.Range()))
 		return ret.RefineNotNull()
@@ -1250,6 +1255,12 @@ func (val Value) And(other Value) Value {
 	}
 
 	if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+		// If either value is known to be exactly False then it doesn't
+		// matter what the other value is, because the final result must
+		// either be False or an error.
+		if val == False || other == False {
+			return False
+		}
 		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
 		return (*shortCircuit).RefineNotNull()
 	}
@@ -1267,6 +1278,12 @@ func (val Value) Or(other Value) Value {
 	}
 
 	if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+		// If either value is known to be exactly True then it doesn't
+		// matter what the other value is, because the final result must
+		// either be True or an error.
+		if val == True || other == True {
+			return True
+		}
 		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
 		return (*shortCircuit).RefineNotNull()
 	}

cty/value_ops_test.go

@@ -2072,12 +2072,22 @@ func TestValueMultiply(t *testing.T) {
 				NumberRangeLowerBound(NumberIntVal(6), true).
 				NewValue(),
 		},
+		{
+			Zero,
+			UnknownVal(Number),
+			Zero,
+		},
+		{
+			UnknownVal(Number),
+			Zero,
+			Zero,
+		},
 		{
 			Zero,
 			UnknownVal(Number).Refine().
 				NumberRangeLowerBound(NumberIntVal(2), false).
 				NewValue(),
-			UnknownVal(Number).RefineNotNull(), // We can't currently refine this case
+			Zero,
 		},
 		{
 			UnknownVal(Number).Refine().
@@ -3033,6 +3043,16 @@ func TestValueAnd(t *testing.T) {
 			True,
 			UnknownVal(Bool).RefineNotNull(),
 		},
+		{
+			False,
+			UnknownVal(Bool),
+			False,
+		},
+		{
+			UnknownVal(Bool),
+			False,
+			False,
+		},
 		{
 			DynamicVal,
 			DynamicVal,
@@ -3048,6 +3068,16 @@ func TestValueAnd(t *testing.T) {
 			True,
 			UnknownVal(Bool).RefineNotNull(),
 		},
+		{
+			False,
+			DynamicVal,
+			False,
+		},
+		{
+			DynamicVal,
+			False,
+			False,
+		},
 		{
 			True.Mark(1),
 			True,
@@ -3109,11 +3139,21 @@ func TestValueOr(t *testing.T) {
 		{
 			True,
 			UnknownVal(Bool),
-			UnknownVal(Bool).RefineNotNull(),
+			True,
 		},
 		{
 			UnknownVal(Bool),
 			True,
+			True,
+		},
+		{
+			False,
+			UnknownVal(Bool),
+			UnknownVal(Bool).RefineNotNull(),
+		},
+		{
+			UnknownVal(Bool),
+			False,
 			UnknownVal(Bool).RefineNotNull(),
 		},
 		{
@@ -3124,11 +3164,21 @@ func TestValueOr(t *testing.T) {
 		{
 			True,
 			DynamicVal,
-			UnknownVal(Bool).RefineNotNull(),
+			True,
 		},
 		{
 			DynamicVal,
 			True,
+			True,
+		},
+		{
+			False,
+			DynamicVal,
+			UnknownVal(Bool).RefineNotNull(),
+		},
+		{
+			DynamicVal,
+			False,
 			UnknownVal(Bool).RefineNotNull(),
 		},
 		{