Merge pull request #5797 from ethereum/faq-array-pass

[DOCS] Remove copy between contracts FAQ item

docs/control-structures.rst

@@ -264,6 +264,31 @@ Complications for Arrays and Structs
 The semantics of assignments are a bit more complicated for non-value types like arrays and structs.
 Assigning *to* a state variable always creates an independent copy. On the other hand, assigning to a local variable creates an independent copy only for elementary types, i.e. static types that fit into 32 bytes. If structs or arrays (including ``bytes`` and ``string``) are assigned from a state variable to a local variable, the local variable holds a reference to the original state variable. A second assignment to the local variable does not modify the state but only changes the reference. Assignments to members (or elements) of the local variable *do* change the state.
 
+In the example below the call to ``g(x)`` has no effect on ``x`` because it needs
+to create an independent copy of the storage value in memory. However ``h(x)`` modifies ``x`` because a reference and
+not a copy is passed.
+
+::
+
+     pragma solidity >=0.4.16 <0.6.0;
+
+     contract C {
+        uint[20] x;
+
+         function f() public {
+            g(x);
+            h(x);
+        }
+
+         function g(uint[20] memory y) internal pure {
+            y[2] = 3;
+        }
+
+         function h(uint[20] storage y) internal {
+            y[3] = 4;
+        }
+    }
+
 .. index:: ! scoping, declarations, default value
 
 .. _default-value:

docs/frequently-asked-questions.rst

@@ -96,36 +96,6 @@ In this example::
         }
     }
 
-Can a contract pass an array (static size) or string or ``bytes`` (dynamic size) to another contract?
-=====================================================================================================
-
-Sure. Take care that if you cross the memory / storage boundary,
-independent copies will be created::
-
-    pragma solidity >=0.4.16 <0.6.0;
-
-    contract C {
-        uint[20] x;
-
-        function f() public {
-            g(x);
-            h(x);
-        }
-
-        function g(uint[20] memory y) internal pure {
-            y[2] = 3;
-        }
-
-        function h(uint[20] storage y) internal {
-            y[3] = 4;
-        }
-    }
-
-The call to ``g(x)`` will not have an effect on ``x`` because it needs
-to create an independent copy of the storage value in memory.
-On the other hand, ``h(x)`` successfully modifies ``x`` because only
-a reference and not a copy is passed.
-
 What does the following strange check do in the Custom Token contract?
 ======================================================================