Python-only build script

stdlib/public/core/IntegerTypes.swift.gyb

@@ -17,7 +17,6 @@
 from SwiftIntTypes import all_integer_types, int_max_bits, should_define_truncating_bit_pattern_init
 from SwiftFloatingPointTypes import getFtoIBounds
 
-from string import maketrans, capitalize
 from itertools import chain
 
 # Number of bits in the Builtin.Word type
@@ -1651,7 +1650,7 @@ extension ${Self} : Hashable {
     return Hasher._hash(
       seed: seed,
       bytes: UInt64(truncatingIfNeeded: ${U}${Self}(_value)),
-      count: ${bits / 8})
+      count: ${int(bits // 8)})
     % end
   }
 }

stdlib/public/core/SIMDVectorTypes.swift.gyb

@@ -76,19 +76,20 @@ public struct SIMD${n}<Scalar> : SIMD where Scalar: SIMDScalar {
 %  end
 % end
 % if n >= 4:
+  % halfN = int(n/2)
   /// Creates a new vector from two half-length vectors.
   @_transparent
-  public init(lowHalf: SIMD${n/2}<Scalar>, highHalf: SIMD${n/2}<Scalar>) {
+  public init(lowHalf: SIMD${halfN}<Scalar>, highHalf: SIMD${halfN}<Scalar>) {
     self.init()
     self.lowHalf = lowHalf
     self.highHalf = highHalf
   }
 
-%  for (half,indx) in [('low','i'), ('high',str(n/2)+'+i'), ('even','2*i'), ('odd','2*i+1')]:
+%  for (half,indx) in [('low','i'), ('high',str(halfN)+'+i'), ('even','2*i'), ('odd','2*i+1')]:
   /// A half-length vector made up of the ${half} elements of the vector.
-  public var ${half}Half: SIMD${n/2}<Scalar> {
+  public var ${half}Half: SIMD${halfN}<Scalar> {
     @inlinable get {
-      var result = SIMD${n/2}<Scalar>()
+      var result = SIMD${halfN}<Scalar>()
       for i in result.indices { result[i] = self[${indx}] }
       return result
     }
@@ -147,7 +148,7 @@ extension SIMD${n} : CustomDebugStringConvertible {
   public var debugDescription: String {
     return "SIMD${n}<\(Scalar.self)>(${', '.join(map(lambda c:
                        '\\(self['+ str(c) + '])',
-                       xrange(n)))})"
+                       range(n)))})"
   }
 }
 
@@ -184,7 +185,7 @@ extension ${Self} : SIMDScalar {
   public typealias SIMDMaskScalar = ${Mask}
 
 % for n in storagescalarCounts:
-%  bytes = n * self_type.bits / 8
+%  bytes = int(n * self_type.bits / 8)
   /// Storage for a vector of ${spelledNumbers[n]} integers.
   @_fixed_layout
   @_alignment(${bytes if bytes <= 16 else 16})
@@ -229,7 +230,7 @@ extension ${Self} : SIMDScalar {
   public typealias SIMDMaskScalar = Int${bits}
 
 % for n in storagescalarCounts:
-%  bytes = n * bits / 8
+%  bytes = int(n * bits / 8)
   /// Storage for a vector of ${spelledNumbers[n]} floating-point values.
   @_fixed_layout
   @_alignment(${bytes if bytes <= 16 else 16})

stdlib/public/core/Tuple.swift.gyb

@@ -111,7 +111,7 @@ public func >=(lhs: (), rhs: ()) -> Bool {
 %   equatableTypeParams = ", ".join(["{} : Equatable".format(c) for c in typeParams])
 
 %   originalTuple = "(\"a\", {})".format(", ".join(map(str, range(1, arity))))
-%   greaterTuple = "(\"a\", {})".format(", ".join(map(str, range(1, arity - 1) + [arity])))
+%   greaterTuple = "(\"a\", {})".format(", ".join(map(str, list(range(1, arity - 1)) + [arity])))
 
 /// Returns a Boolean value indicating whether the corresponding components of
 /// two tuples are equal.

test/Driver/response-file-merge-modules.swift

@@ -1,4 +1,4 @@
-// RUN: %{python} -c 'for i in range(500001): print "-DTEST_" + str(i)' > %t.resp
+// RUN: %{python} -c 'for i in range(500001): print("-DTEST_" + str(i))' > %t.resp
 // RUN: %swiftc_driver -driver-print-jobs -module-name merge -emit-module %S/Inputs/main.swift %S/Inputs/lib.swift @%t.resp 2>&1 > %t.jobs.txt
 // RUN: %FileCheck %s < %t.jobs.txt -check-prefix=MERGE
 

test/Driver/response-file.swift

@@ -2,7 +2,7 @@
 // RUN: %target-build-swift -typecheck @%t.0.resp %s 2>&1 | %FileCheck %s -check-prefix=SHORT
 // SHORT: warning: result of call to 'abs' is unused
 
-// RUN: %{python} -c 'for a in ["A", "B", "C", "D"]: print "-DTEST1" + a' > %t.1.resp
+// RUN: %{python} -c 'for a in ["A", "B", "C", "D"]: print("-DTEST1" + a)' > %t.1.resp
 // RUN: %target-build-swift -typecheck @%t.1.resp %s 2>&1 | %FileCheck %s -check-prefix=MULTIPLE
 // MULTIPLE: warning: result of call to 'abs' is unused
 
@@ -24,7 +24,7 @@
 // RUN: %target-build-swift -typecheck @%t.4B.resp 2>&1 | %FileCheck %s -check-prefix=RECURSIVE
 // RECURSIVE: warning: result of call to 'abs' is unused
 
-// RUN: %{python} -c 'for i in range(500001): print "-DTEST5_" + str(i)' > %t.5.resp
+// RUN: %{python} -c 'for i in range(500001): print("-DTEST5_" + str(i))' > %t.5.resp
 // RUN: %target-build-swift -typecheck @%t.5.resp %s 2>&1 | %FileCheck %s -check-prefix=LONG
 // LONG: warning: result of call to 'abs' is unused
 // RUN: %empty-directory(%t/tmp)

test/Serialization/Inputs/binary_sub.py

@@ -5,5 +5,14 @@
 (_, old, new) = sys.argv
 assert(len(old) == len(new))
 
-data = sys.stdin.read()
-sys.stdout.write(data.replace(old, new))
+if sys.version_info[0] == 2:
+    stdin = sys.stdin
+    stdout = sys.stdout
+else:
+    stdin = sys.stdin.buffer
+    stdout = sys.stdout.buffer
+    old = old.encode()
+    new = new.encode()
+
+data = stdin.read()
+stdout.write(data.replace(old, new))

test/Syntax/tokens_unknown_and_invalid.swift

@@ -6,7 +6,7 @@
 // marker is also represented in escape sequence.
 
 // RUN: cat %s | sed -f %S/Inputs/invalid.sed > %t
-// RUN: %{python} -c "import sys; t = open(sys.argv[1], 'rb').read().replace('\r\n', '\n'); open(sys.argv[1], 'wb').write(t)" %t
+// RUN: %{python} -c "import sys; t = open(sys.argv[1], 'rb').read().replace('\r\n'.encode(), '\n'.encode()); open(sys.argv[1], 'wb').write(t)" %t
 // RUN: %swift-syntax-test -input-source-filename %t -dump-full-tokens 2>&1 | %FileCheck %t
 // RUN: %round-trip-syntax-test --swift-syntax-test %swift-syntax-test --file %t
 

test/lit.cfg

@@ -1117,7 +1117,7 @@ source_compiler_rt_libs(compiler_rt_dir)
 
 def check_runtime_libs(features_to_check):
     for lib in config.compiler_rt_libs:
-        for (libname, feature) in features_to_check.iteritems():
+        for (libname, feature) in features_to_check.items():
             if lib.startswith("libclang_rt." + libname + "_"):
                 config.available_features.add(feature)
 

test/stdlib/Inputs/FixedPointConversion.swift.gyb

@@ -40,7 +40,10 @@ int_to_int_conversion_template = gyb.parse_template("int_to_int_conversion",
 """
 %{
 from SwiftIntTypes import all_integer_types, int_max, int_min
-from SwiftFloatingPointTypes import all_floating_point_types
+from SwiftFloatingPointTypes import all_floating_point_types, getFtoIBounds
+
+from decimal import Decimal
+
 
 }%
 % for self_ty in all_integer_types(word_bits):
@@ -105,51 +108,53 @@ FixedPointConversionFailure.test("${Other}To${Self}Conversion/dest=${testValue}"
 %     Other = "Float" + str(other_type.bits)
 %     otherMin = -int_max(bits=other_type.explicit_significand_bits, signed=False)
 %     otherMax = int_max(bits=other_type.explicit_significand_bits, signed=False)
+%     (selfFtoIMin, selfFtoIMax) = getFtoIBounds(other_type.bits, selfBits, selfSigned)
 
 %     if Other == 'Float80':
 #if !os(Windows) && (arch(i386) || arch(x86_64))
 %     end
 
-%     for testValue in [repr(value) for value in [selfMin, selfMax, selfMin - 0.1, selfMax + 0.1, otherMin, otherMax, 0.0, -0.0, 0.1, -0.1]]:
+%     for testValue in [Decimal(selfMin), Decimal(selfMax), Decimal(selfFtoIMin) - Decimal('0.1'), Decimal(selfFtoIMax) + Decimal('0.1'), Decimal(otherMin), Decimal(otherMax), Decimal('0.0'), Decimal('-0.0'), Decimal('0.1'), Decimal('-0.1')]:
+%       testValueStr = str(testValue)
 
 %       if testValue < otherMin or testValue > otherMax:
 %         # Can't construct `other` value to test from, do nothing and continue.
 
-%       elif testValue >= selfMin and testValue <= selfMax and testValue % 1 == 0 and testValue != -0.0:
+%       elif testValue >= selfFtoIMin and testValue <= selfFtoIMax and (testValue % 1).is_zero():
 
-FloatingPointConversionTruncations.test("${Other}To${Self}Conversion/dest=${testValue}") {
-  let input = get${Other}(${testValue})
+FloatingPointConversionTruncations.test("${Other}To${Self}Conversion/dest=${testValueStr}") {
+  let input = get${Other}(${testValueStr})
   let result = ${Self}(input)
   var resultConvertedBack = ${Other}(result)
-  expectEqual(${testValue}, resultConvertedBack)
+  expectEqual(${testValueStr}, resultConvertedBack)
 }
 
-FloatingPointConversionFailures.test("${Other}To${Self}FailableConversion/dest=${testValue}") {
-  let input = get${Other}(${testValue})
-  expectNil(${Self}(exactly: input))
+FloatingPointConversionFailures.test("${Other}To${Self}FailableConversion/dest=${testValueStr}") {
+  let input = get${Other}(${testValueStr})
+  expectNotNil(${Self}(exactly: input))
 }
 
 %       else:
 
-%         if testValue > selfMax:
-FloatingPointConversionTraps.test("${Other}To${Self}Conversion/dest=${testValue}")
+%         if testValue > selfFtoIMax:
+FloatingPointConversionTraps.test("${Other}To${Self}Conversion/dest=${testValueStr}")
 .crashOutputMatches(getTooLargeMessage()).code {
   expectCrashLater()
-%         elif testValue < selfMin:
-FloatingPointConversionTraps.test("${Other}To${Self}Conversion/dest=${testValue}")
+%         elif testValue < selfFtoIMin:
+FloatingPointConversionTraps.test("${Other}To${Self}Conversion/dest=${testValueStr}")
 .crashOutputMatches(getTooSmallMessage()).code {
   expectCrashLater()
 %         else:
-FloatingPointConversionTruncations.test("${Other}To${Self}Conversion/dest=${testValue}") {
+FloatingPointConversionTruncations.test("${Other}To${Self}Conversion/dest=${testValueStr}") {
 %         end
-  let input = get${Other}(${testValue})
+  let input = get${Other}(${testValueStr})
   var result = ${Self}(input)
   var resultConvertedBack = ${Other}(result)
   expectNotEqual(input, resultConvertedBack)
 }
 
-FloatingPointConversionFailures.test("${Other}To${Self}Conversion/dest=${testValue}") {
-  let input = get${Other}(${testValue})
+FloatingPointConversionFailures.test("${Other}To${Self}Conversion/dest=${testValueStr}") {
+  let input = get${Other}(${testValueStr})
   expectNil(${Self}(exactly: input))
 }
 %       end

test/stdlib/NumericParsing.swift.gyb

@@ -36,7 +36,7 @@ Note: the third parameter, zero, is not for user consumption.
   else:
     r = n % radix
     digit = chr((ord('0') + r) if r < 10 else (ord('a') + r - 10))
-    return inRadix(radix, int(n / radix), '') + digit
+    return inRadix(radix, int(n // radix), '') + digit
 
 # The maximal legal radix
 max_radix = ord('z') - ord('a') + 1 + 10

utils/PathSanitizingFileCheck

@@ -15,6 +15,7 @@ import argparse
 import subprocess
 import sys
 
+is_py2 = sys.version_info[0] == 2
 
 def main():
     parser = argparse.ArgumentParser(
@@ -44,10 +45,10 @@ constants.""")
 
     args, unknown_args = parser.parse_known_args()
 
-    stdin = sys.stdin.read()
+    stdin = sys.stdin.read() if is_py2 else sys.stdin.buffer.read()
     for s in args.sanitize_strings:
         replacement, pattern = s.split('=', 1)
-        stdin = stdin.replace(pattern, replacement)
+        stdin = stdin.replace(pattern.encode(), replacement.encode())
 
     p = subprocess.Popen(
         [args.file_check_path] + unknown_args, stdin=subprocess.PIPE)