Oh. This is incorrect. Should be reverted to ```atoms(Symbol)```. Please refer the example given below.

From modified file,
```
In [0]: construct_domain([Integral(x*y/2, (x, 0, 2)),Integral(x*y/2, (y, 0, 3))],composite=None)
Out[0]: 
⎛ ⎡2         3       ⎤                                                          ⎞
⎜ ⎢⌠         ⌠       ⎥                                                          ⎟
⎜ ⎢⎮ x⋅y     ⎮ x⋅y   ⎥                                                          ⎟
⎜ℤ⎢⎮ ─── dx, ⎮ ─── dy⎥, [Integral(x*y/2, (x, 0, 2)), Integral(x*y/2, (y, 0, 3))]⎟
⎜ ⎢⎮  2      ⎮  2    ⎥                                                          ⎟
⎜ ⎢⌡         ⌡       ⎥                                                          ⎟
⎝ ⎣0         0       ⎦                                                          ⎠
```
while actual (master) output should be,
```
In [1]: construct_domain([Integral(x*y/2, (x, 0, 2)),Integral(x*y/2, (y, 0, 3))],composite=None)
Out[1]: (EX, [EX(Integral(x*y/2, (x, 0, 2))), EX(Integral(x*y/2, (y, 0, 3)))])
```

Please refer the line:125 onwards in ```sympy/polys/constructor.py```. 
```python
    if opt.composite is None:
        if any(gen.is_number for gen in gens):
            return None # generators are number-like so lets better use EX

        all_symbols = set([])

        for gen in gens:
            symbols = gen.free_symbols  <-----(1)

            if all_symbols & symbols:  <-----(2)
                return None # there could be algebraic relations between generators
            else:
                all_symbols |= symbols

```
If we use ```free_symbols``` in line (1), then in line (2); ```all_symbols``` will be only compared with ```free_symbols``` of ```gen``` where it should be compared with all variables of an expression. Therefore going with ```free_symbols``` should not be emphasized here as far as I am concerned.

This will be reverted in a future commit.