Small cleanup of updating _lazyTensor to _lazyTensorHandle (#920)

Author: ematejska

Tests/TensorFlowTests/LazyTensorHandleTests.swift

@@ -124,10 +124,10 @@ final class LazyTensorHandleTests: XCTestCase {
   private func checkConversions<T: _LazyTensorCompatible>(_ x: T) {
     let concreteLazyX = x._concreteLazyTensor
     let concreteInputLazyX = x._concreteInputLazyTensor
-    XCTAssertFalse(isSymbolic(concreteLazyX._lazyTensor))
-    XCTAssertFalse(isSymbolic(concreteInputLazyX._lazyTensor))
-    XCTAssertFalse(isMaterializedConcrete(concreteLazyX._lazyTensor))
-    XCTAssertTrue(isMaterializedConcrete(concreteInputLazyX._lazyTensor))
+    XCTAssertFalse(isSymbolic(concreteLazyX._lazyTensorHandle))
+    XCTAssertFalse(isSymbolic(concreteInputLazyX._lazyTensorHandle))
+    XCTAssertFalse(isMaterializedConcrete(concreteLazyX._lazyTensorHandle))
+    XCTAssertTrue(isMaterializedConcrete(concreteInputLazyX._lazyTensorHandle))
   }
 
   func testTensorToLazyTensorConversions() {

Tests/TensorFlowTests/LazyTensorShapeInferenceTests.swift

@@ -28,9 +28,9 @@ final class LazyTensorShapeInferenceTests: LazyTensorTestCase {
     let b = Tensor<Float>(shape: [1, 3], scalars: [1.0, 2.0, 3.0])
     let c = Tensor<Float>(shape: [1, 3], scalars: [4.0, 5.0, 6.0])
     let w = a * b
-    let wLazyTensorOperation = w._lazyTensor!.lazyTensorOperation!
+    let wLazyTensorOperation = w._lazyTensorHandle!.lazyTensorOperation!
     let x = w * c
-    let xLazyTensorOperation = x._lazyTensor!.lazyTensorOperation!
+    let xLazyTensorOperation = x._lazyTensorHandle!.lazyTensorOperation!
 
     // Make sure that `w` and `x` are not materialized.
     XCTAssertFalse(wLazyTensorOperation.isMaterialized)
@@ -60,7 +60,7 @@ final class LazyTensorShapeInferenceTests: LazyTensorTestCase {
     let a = Tensor<Float>(shape: [3, 1], scalars: [1.0, 2.0, 3.0])
     let b = a.reshaped(toShape: [1, 3])
 
-    let bLazyTensorOperation = b._lazyTensor!.lazyTensorOperation!
+    let bLazyTensorOperation = b._lazyTensorHandle!.lazyTensorOperation!
     XCTAssertFalse(bLazyTensorOperation.isMaterialized)
 
     let bShape = b.shape
@@ -69,7 +69,7 @@ final class LazyTensorShapeInferenceTests: LazyTensorTestCase {
     XCTAssertFalse(bLazyTensorOperation.isMaterialized)
 
     let c = Tensor<Float>(repeating: 5, shape: [4, 5, 6])
-    let cLazyTensorOperation = c._lazyTensor!.lazyTensorOperation!
+    let cLazyTensorOperation = c._lazyTensorHandle!.lazyTensorOperation!
     XCTAssertFalse(cLazyTensorOperation.isMaterialized)
 
     let cShape = c.shape
@@ -91,7 +91,7 @@ final class LazyTensorShapeInferenceTests: LazyTensorTestCase {
     let dims = a + b
     let m = _Raw.fill(dims: dims, value: Tensor<Float>(1.0))
     let result = _Raw.matMul(m, m)
-    let mLazyTensorOperation = m._lazyTensor!.lazyTensorOperation!
+    let mLazyTensorOperation = m._lazyTensorHandle!.lazyTensorOperation!
     // Note that we have not triggered materialization yet. So, it should not have happened
     // implicitly during shape inference.
     XCTAssertFalse(mLazyTensorOperation.isMaterialized)

Tests/TensorFlowTests/LazyTensorTestHelper.swift

@@ -34,7 +34,7 @@ class LazyTensorTestCase: XCTestCase {
 
 protocol _LazyTensorCompatible {
   /// The underlying `LazyTensorHandle` (if any).
-  var _lazyTensor: LazyTensorHandle? { get }
+  var _lazyTensorHandle: LazyTensorHandle? { get }
 
   /// Returns `Self` that wraps a concrete `LazyTensorHandle`.
   /// (Triggers materialization if needed.)
@@ -47,7 +47,7 @@ protocol _LazyTensorCompatible {
 }
 
 extension _AnyTensorHandle {
-  var _lazyTensor: LazyTensorHandle? {
+  var _lazyTensorHandle: LazyTensorHandle? {
     if let handle = self as? LazyTensorHandle {
       return handle
     } else {
@@ -58,35 +58,35 @@ extension _AnyTensorHandle {
 }
 
 extension TensorHandle: _LazyTensorCompatible {
-  var _lazyTensor: LazyTensorHandle? { handle._lazyTensor }
+  var _lazyTensorHandle: LazyTensorHandle? { handle._lazyTensorHandle }
   public var _concreteLazyTensor: TensorHandle {
     TensorHandle(handle: handle._concreteLazyTensor)
   }
 }
 
 extension Tensor: _LazyTensorCompatible {
-  var _lazyTensor: LazyTensorHandle? { handle._lazyTensor }
+  var _lazyTensorHandle: LazyTensorHandle? { handle._lazyTensorHandle }
   public var _concreteLazyTensor: Tensor {
     Tensor(handle: handle._concreteLazyTensor)
   }
 }
 
 extension StringTensor: _LazyTensorCompatible {
-  var _lazyTensor: LazyTensorHandle? { handle._lazyTensor }
+  var _lazyTensorHandle: LazyTensorHandle? { handle._lazyTensorHandle }
   public var _concreteLazyTensor: StringTensor {
     StringTensor(handle: handle._concreteLazyTensor)
   }
 }
 
 extension VariantHandle: _LazyTensorCompatible {
-  var _lazyTensor: LazyTensorHandle? { handle._lazyTensor }
+  var _lazyTensorHandle: LazyTensorHandle? { handle._lazyTensorHandle }
   public var _concreteLazyTensor: VariantHandle {
     VariantHandle(handle: handle._concreteLazyTensor)
   }
 }
 
 extension ResourceHandle: _LazyTensorCompatible {
-  var _lazyTensor: LazyTensorHandle? { handle._lazyTensor }
+  var _lazyTensorHandle: LazyTensorHandle? { handle._lazyTensorHandle }
   public var _concreteLazyTensor: ResourceHandle {
     ResourceHandle(handle: handle._concreteLazyTensor)
   }