Fix a case in a rarely-applied optimization, add test.

theano/tensor/opt.py

@@ -2742,10 +2742,10 @@ def local_add_specialize(node):
             new_inputs.append(input)
 
         if len(new_inputs) < len(node.inputs):
+            dtype = node.outputs[0].type.dtype
             if len(new_inputs) == 0:
                 #we got rid of the entire expression!
                 ndim = node.outputs[0].type.ndim
-                dtype = node.outputs[0].type.dtype
                 return fill_chain(
                         T.TensorConstant(
                             T.TensorType(
@@ -2754,9 +2754,14 @@ def local_add_specialize(node):
                             numpy.zeros((1,)*ndim, dtype=dtype)))
 
             if len(new_inputs) == 1:
-                return fill_chain(new_inputs[0])
+                ret = fill_chain(new_inputs[0])
             else:
-                return fill_chain(T.add(*new_inputs))
+                ret = fill_chain(T.add(*new_inputs))
+            # The dtype should not be changed. It can happen if the input
+            # that was forcing upcasting was equal to 0.
+            if ret[0].dtype != dtype:
+                ret = [T.cast(ret[0], dtype)]
+            return ret
     else:
         return False
 register_specialize(local_add_specialize)

theano/tensor/tests/test_opt.py

@@ -2753,6 +2753,14 @@ def test_local_add_specialize():
     s = tensor.add(tensor.zeros_like(a))
     assert local_add_specialize.transform(s.owner)
 
+    # Test when the 0 input is forcing upcasting
+    a = tensor.constant(0, dtype='int64')
+    b = tensor.constant(1, dtype='int32')
+    s = a + b
+    transformed = local_add_specialize.transform(s.owner)
+    assert transformed
+    assert transformed[0].type == s.type
+
 def test_local_tensor_scalar_tensor():
     dtypes = ['int8', 'int16', 'int32', 'int64',
             'uint8', 'uint16', 'uint32', 'uint64',