Bug 1906461 - Make more of the LogicalGeometry impl dependent on Clone versus Copy r=emilio

Differential Revision: https://phabricator.services.mozilla.com/D215843

Author: mrobinson

style/logical_geometry.rs

@@ -480,14 +480,14 @@ impl<T> LogicalSize<T> {
     }
 }
 
-impl<T: Copy> LogicalSize<T> {
+impl<T: Clone> LogicalSize<T> {
     #[inline]
     pub fn width(&self, mode: WritingMode) -> T {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
-            self.block
+            self.block.clone()
         } else {
-            self.inline
+            self.inline.clone()
         }
     }
 
@@ -505,9 +505,9 @@ impl<T: Copy> LogicalSize<T> {
     pub fn height(&self, mode: WritingMode) -> T {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
-            self.inline
+            self.inline.clone()
         } else {
-            self.block
+            self.block.clone()
         }
     }
 
@@ -525,17 +525,17 @@ impl<T: Copy> LogicalSize<T> {
     pub fn to_physical(&self, mode: WritingMode) -> Size2D<T> {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
-            Size2D::new(self.block, self.inline)
+            Size2D::new(self.block.clone(), self.inline.clone())
         } else {
-            Size2D::new(self.inline, self.block)
+            Size2D::new(self.inline.clone(), self.block.clone())
         }
     }
 
     #[inline]
     pub fn convert(&self, mode_from: WritingMode, mode_to: WritingMode) -> LogicalSize<T> {
         if mode_from == mode_to {
             self.debug_writing_mode.check(mode_from);
-            *self
+            self.clone()
         } else {
             LogicalSize::from_physical(mode_to, self.to_physical(mode_from))
         }
@@ -908,23 +908,23 @@ impl<T> LogicalMargin<T> {
     }
 }
 
-impl<T: Copy> LogicalMargin<T> {
+impl<T: Clone> LogicalMargin<T> {
     #[inline]
     pub fn new_all_same(mode: WritingMode, value: T) -> LogicalMargin<T> {
-        LogicalMargin::new(mode, value, value, value, value)
+        LogicalMargin::new(mode, value.clone(), value.clone(), value.clone(), value)
     }
 
     #[inline]
     pub fn top(&self, mode: WritingMode) -> T {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
             if mode.is_inline_tb() {
-                self.inline_start
+                self.inline_start.clone()
             } else {
-                self.inline_end
+                self.inline_end.clone()
             }
         } else {
-            self.block_start
+            self.block_start.clone()
         }
     }
 
@@ -947,15 +947,15 @@ impl<T: Copy> LogicalMargin<T> {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
             if mode.is_vertical_lr() {
-                self.block_end
+                self.block_end.clone()
             } else {
-                self.block_start
+                self.block_start.clone()
             }
         } else {
             if mode.is_bidi_ltr() {
-                self.inline_end
+                self.inline_end.clone()
             } else {
-                self.inline_start
+                self.inline_start.clone()
             }
         }
     }
@@ -983,12 +983,12 @@ impl<T: Copy> LogicalMargin<T> {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
             if mode.is_inline_tb() {
-                self.inline_end
+                self.inline_end.clone()
             } else {
-                self.inline_start
+                self.inline_start.clone()
             }
         } else {
-            self.block_end
+            self.block_end.clone()
         }
     }
 
@@ -1011,15 +1011,15 @@ impl<T: Copy> LogicalMargin<T> {
         self.debug_writing_mode.check(mode);
         if mode.is_vertical() {
             if mode.is_vertical_lr() {
-                self.block_start
+                self.block_start.clone()
             } else {
-                self.block_end
+                self.block_end.clone()
             }
         } else {
             if mode.is_bidi_ltr() {
-                self.inline_start
+                self.inline_start.clone()
             } else {
-                self.inline_end
+                self.inline_end.clone()
             }
         }
     }
@@ -1051,28 +1051,28 @@ impl<T: Copy> LogicalMargin<T> {
         let left;
         if mode.is_vertical() {
             if mode.is_vertical_lr() {
-                left = self.block_start;
-                right = self.block_end;
+                left = self.block_start.clone();
+                right = self.block_end.clone();
             } else {
-                right = self.block_start;
-                left = self.block_end;
+                right = self.block_start.clone();
+                left = self.block_end.clone();
             }
             if mode.is_inline_tb() {
-                top = self.inline_start;
-                bottom = self.inline_end;
+                top = self.inline_start.clone();
+                bottom = self.inline_end.clone();
             } else {
-                bottom = self.inline_start;
-                top = self.inline_end;
+                bottom = self.inline_start.clone();
+                top = self.inline_end.clone();
             }
         } else {
-            top = self.block_start;
-            bottom = self.block_end;
+            top = self.block_start.clone();
+            bottom = self.block_end.clone();
             if mode.is_bidi_ltr() {
-                left = self.inline_start;
-                right = self.inline_end;
+                left = self.inline_start.clone();
+                right = self.inline_end.clone();
             } else {
-                right = self.inline_start;
-                left = self.inline_end;
+                right = self.inline_start.clone();
+                left = self.inline_end.clone();
             }
         }
         SideOffsets2D::new(top, right, bottom, left)
@@ -1082,7 +1082,7 @@ impl<T: Copy> LogicalMargin<T> {
     pub fn convert(&self, mode_from: WritingMode, mode_to: WritingMode) -> LogicalMargin<T> {
         if mode_from == mode_to {
             self.debug_writing_mode.check(mode_from);
-            *self
+            self.clone()
         } else {
             LogicalMargin::from_physical(mode_to, self.to_physical(mode_from))
         }