Fix BaseFormOperator.ufl_function_space (#377)

* Fix BaseFormOperator.ufl_function_space

* retrigger CI

Author: pbrubeck

test/test_interpolate.py

@@ -56,11 +56,8 @@ def V2(domain_2d):
 
 
 def test_symbolic(V1, V2):
-    # Set dual of V2
-    V2_dual = V2.dual()
-
     u = Coefficient(V1)
-    vstar = Argument(V2_dual, 0)
+    vstar = Argument(V2.dual(), 0)
     Iu = Interpolate(u, vstar)
 
     assert Iu == Interpolate(u, V2)
@@ -71,17 +68,17 @@ def test_symbolic(V1, V2):
 
 
 def test_symbolic_adjoint(V1, V2):
-    # Set dual of V2
-    V2_dual = V2.dual()
-
     u = Argument(V1, 1)
-    vstar = Cofunction(V2_dual)
-    Iu = Interpolate(u, vstar)
+    form = inner(1, Argument(V2, 0)) * dx
+    cofun = Cofunction(V2.dual())
 
-    assert Iu.ufl_function_space() == V2_dual
-    assert Iu.argument_slots() == (vstar, u)
-    assert Iu.arguments() == (u,)
-    assert Iu.ufl_operands == (u,)
+    for vstar in (form, cofun):
+        Iu = Interpolate(u, vstar)
+
+        assert Iu.ufl_function_space() == V1.dual()
+        assert Iu.argument_slots() == (vstar, u)
+        assert Iu.arguments() == (u,)
+        assert Iu.ufl_operands == (u,)
 
 
 def test_action_adjoint(V1, V2):

ufl/core/base_form_operator.py

@@ -17,7 +17,6 @@
 from numbers import Number
 
 from ufl.argument import Argument, Coargument
-from ufl.coefficient import BaseCoefficient
 from ufl.constantvalue import as_ufl
 from ufl.core.operator import Operator
 from ufl.core.ufl_type import ufl_type
@@ -135,21 +134,21 @@ def count(self):
 
     @property
     def ufl_shape(self):
-        """Return the UFL shape of the coefficient.produced by the operator."""
-        arg, *_ = self.argument_slots()
-        if not isinstance(arg, BaseCoefficient) and isinstance(arg, (BaseForm, Coargument)):
-            arg, *_ = arg.arguments()
+        """Return the UFL shape of the coefficient produced by the operator."""
+        if len(self.arguments()) == 0:
+            return ()
+        arg, *_ = self.arguments()
         return arg._ufl_shape
 
     def ufl_function_space(self):
         """Return the function space associated to the operator.
 
         I.e. return the dual of the base form operator's Coargument space.
         """
-        arg, *_ = self.argument_slots()
-        if not isinstance(arg, BaseCoefficient) and isinstance(arg, (BaseForm, Coargument)):
-            arg, *_ = arg.arguments()
-        return arg.ufl_function_space()
+        if len(self.arguments()) == 0:
+            return None
+        arg, *_ = self.arguments()
+        return arg.ufl_function_space().dual()
 
     def _ufl_expr_reconstruct_(
         self, *operands, function_space=None, derivatives=None, argument_slots=None