Make int.gcd accept zero operands.

runtime/lib/bigint.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 /*
  * Copyright (c) 2003-2005  Tom Wu
@@ skipping 1540 matching lines @@
     final m_len = m_used + (m_used & 1);
     x_digits = _cloneDigits(x_digits, 0, x_used, m_len);
     y_digits = _cloneDigits(y_digits, 0, y_used, m_len);
     int s = 0;
     if (inv) {
       if ((y_used == 1) && (y_digits[0] == 1)) return 1;
       if ((y_used == 0) || (y_digits[0].isEven && x_digits[0].isEven)) {
         throw new UnsupportedError("Not coprime");
       }
     } else {
-      if (x_used == 0) {
-        throw new ArgumentError.value(0, "first operand", "must not be zero");
-      }
-      if (y_used == 0) {
-        throw new ArgumentError.value(0, "second operand", "must not be zero");
+      if ((x_used == 0) && (y_used == 0)) {
+        throw new ArgumentError.value(0, null,
+                                      "at least one operand must not be zero");

[floitsch, 2015/06/24 12:18:13]

Wolfram Alpha goes as far as to say that gcd(0, 0) => 0

[Lasse Reichstein Nielsen, 2015/06/24 12:44:10]

It's a usable definition, as long as you can explain to the user that 0 is the
greatest divisor of all (by being the top element in the lattice of integers
ordered by divisibility, and gcd being the meet operation on that lattice).
Well, or we can just say it's a special case :)

On the other hand, it does avoid throwing a not very helpful error message.

       }
       if (((x_used == 1) && (x_digits[0] == 1)) ||
           ((y_used == 1) && (y_digits[0] == 1))) return 1;
       bool xy_cloned = false;
       while (x.isEven && y.isEven) {
         _rsh(x_digits, x_used, 1, x_digits);
         _rsh(y_digits, y_used, 1, y_digits);
         s++;
       }
       if (s >= _DIGIT_BITS) {
@@ skipping 222 matching lines @@
     if (m == 1) return 0;
     m = m._toBigint();
     var t = this;
     if (t._neg || (t._absCompare(m) >= 0)) {
       t %= m;
       t = t._toBigint();
     }
     return _binaryGcd(m, t, true);
   }
 
   // Returns gcd of abs(this) and abs(other), with this != 0 and other !=0.

[floitsch, 2015/06/24 12:18:13]

comment is not correct anymore.

[Lasse Reichstein Nielsen, 2015/06/24 12:44:10]

Good catch.

   int gcd(int other) {
     if (other is! int) {
       throw new ArgumentError.value(other, "other", "not an integer");
     }
+    if (other == 0) {

[floitsch, 2015/06/24 12:18:13]

Are we sure that bigints cannot be 0?
(If yes assert it, and add comment).

[Lasse Reichstein Nielsen, 2015/06/24 12:44:10]

They can be 0, at least internally. The `other._toBigInt()` call below would be
used for 0 before this change. 
I don't think an externally visible BigInt will be 0. The call to _toValidInt()
above is there to prevent that.

[regis, 2015/06/24 16:07:16]

Correct. At this point, 'other' has not yet been forced to Bigint (either here
or in the forwarding gcd of integers.dart), and 0 is still Smi. We would assert
fault when using '== 0' otherwise.

+      return this.abs();
+    }
     return _binaryGcd(this, other._toBigint(), false);
   }
 }
 
 // Interface for modular reduction.
 class _Reduction {
   // Return the number of digits used by r_digits.
   int _convert(_Bigint x, Uint32List r_digits);
   int _mul(Uint32List x_digits, int x_used,
            Uint32List y_digits, int y_used, Uint32List r_digits);
@@ skipping 258 matching lines @@
 
   int _mul(Uint32List x_digits, int x_used,
            Uint32List y_digits, int y_used,
            Uint32List r_digits) {
     var r_used = _Bigint._mulDigits(x_digits, x_used,
                                     y_digits, y_used,
                                     r_digits);
     return _reduce(r_digits, r_used);
   }
 }