[Chapel Merge] Enable int -> uint, int -> real(32), and improve d

mppf1 · August 31, 2022, 9:04pm

Branch: refs/heads/main
Revision: e0f13ac
Author: mppf
Link: Enable int -> uint, int -> real(32), and improve disambiguation by mppf · Pull Request #20528 · chapel-lang/chapel · GitHub
Log Message:

Merge pull request #20528 from mppf/i64+r32-2

Enable int -> uint, int -> real(32), and improve disambiguation

Goals and Motivation

This PR has 3 major goals:

Enable all integral types to implicitly convert to real(32), and,
relatedly, arrange for myInt + myReal32 to produce a real(32).
This is in response to a user request. See discussion on issue #7740.
Allow signed integral types to implicitly convert to unsigned
integral types of the same size. The reason for this change is that
it avoids having myInt + myUint result in a real(64) and
similarly avoids having myInt32 + myUint32 result in an int(64).
In both cases, the change in the bit width being used can be more
surprising than simply converting to uint. The myInt + myUint
case is particularly problematic because code that appears to work
only with integer types should not suddenly start using floating
point numbers just because of a mixture between int and uint. Note
that, previous to this PR, there was an error overload for + on
int/uint in ChapelBase. However, there are two problems with that
approach. First, it led to other problems such as #17756. Second, it
does not support the goal of making it easy for users to write their
own functions that behave like + does. See also issue #20091.
To simplify the disambiguation rules both so that they are more
understandable and so that we can resolve observed cases where the
partial order is nonsensically nontransitive. See #19195.

Summary of behavior changes

var x = 1:int(8) + 2; // non-default-sized params no longer are special
writeln(x.type:string); // now outputs `int(64)` vs `int(8)` before

// One example of that I found in a test:
const nI = ((-2):int(32))**53;
// this now produces a negative int(64), where previously it produced 0:int(32)

proc dbm(a:int(8)) { writeln("dbm int8"); }
proc dbm(a:uint(64)) { writeln("dbm uint64"); }

dbm(42:int(64)); // now calls dbm(uint(64)) b/c of same-width rule

// this generates a uint(8) range b/c int can coerce to uint
// but previously they would use the next-size-up int
var r8 = 1:int(8)..100:uint(8);
writeln(r8.type:string);

// since 1:int(8) + 10 would result in an int(64),
// this one would most naturally produce an int(64) range.
// However, I have made range module updates to keep
// it working. This this pattern occurs a bunch of times in tests.
var r = 1:int(8)..10;
writeln(r.type:string);


proc f(arg: int) { writeln("f int"); }
{
  proc f(arg) { writeln("f generic"); }
  f(1); // main calls f int, now calls f generic
        // (but main would have called the inner one if it was arg:real)
        // now the visibility check is applied first more consistently
}

var myInt: int = 1;
var myUint: uint = 2;
var a = min(myInt, myUint); // now produces an 'int' but previously produced a 'real'
writeln("min(myInt, myUint) produces ", a.type:string);
var b = max(myInt, myUint); // now produces a 'uint' but previously produced a 'real'
writeln("max(myInt, myUint) produces ", b.type:string);

New Rules

(compare with Procedures — Chapel Documentation 1.27 and Expressions - C# language specification | Microsoft Docs)

Determining More Specific Functions

Given a set of candidate functions, the following steps are applied to
remove candidates from the set, until the best functions are determined.

If any candidate is more visible (or shadows) another candidate,
discard all candidates that are less visible than (or shadowed by)
another candidate.
If at least one candidate requires promotion and at least one
candidate does not use promotion, discard all candidates that use
promotion.
Discard any function that has a less specific argument mapping than
any other function. See the below section for details on the more
specific argument mapping relation.
Discard any candidates that have more formals that require implicit
conversion than other candidates. For this step, implicit conversions
between real(w), imag(w), and complex(2*w) are not considered.
Discard any candidates that have more formals that require a negative
param value is converted to an unsigned integral type of any width
(i.e. a uint(?w)).
Discard any candidates that have more formals that require param
narrowing conversions than another candidate. A param narrowing
conversion is when a param value is implicitly converted to a type
that would not normally be allowed. For example, an int value cannot
normally implicitly convert to an int(8) value. However, the param
value 1, which is an int, can implicitly convert to int(8)
because the value is known to fit.
If at least one candidate has a where clause and at least one
candidate does not have a where clause, discard all candidates that
do not have a where clause.

More Specific Argument Mappings

Given candidate functions X and Y with formal arguments X1 X2 ... and Y1
Y2 ... that correspond to actual arguments A1 A2 ..., which candidate
function is more specific is determined in two steps. First, the
non-param actual arguments and their corresponding formal arguments are
considered. Then, any param actual arguments and their corresponding
formal arguments are considered.

Within each of those steps, the candidate function X has a more specific
argument mapping if:

for each argument considered, the argument mapping from Ai to Yi is
not better than the argument mapping for the argument Ai to Xi, and
for at least one argument considered, the argument mapping from Ai to
Xi is better than the argument mapping from Ai to Yi

Better Argument Mapping

Given an actual argument Ai and the corresponding formals arguments Xi
and Yi (in the functions X and Y being considered), the following rules
are applied in order to determine whether Xi or Yi is a better argument
mapping:

If one of the formals requires promotion and the other does not, the
formal not requiring promotion is better
If one of the formals is less generic than the other formal, the
less-generic formal is better
If one of the formals is param and the other is not, the param
formal is better
If one of the formals requires a param narrowing conversion and the
other is not, the one not requiring such narrowing is better
If the actual and both formals are numeric types and one formals is a
preferred numeric conversion target, that formal is better
If one of the formals matches the actual type exactly and the other
does not, the matching formal is better
If the actual's scalar type for promotion matches one of the formals
but not the other, the matching formal is better
If an implicit conversion is possible from the type of one formal to
the other, but not vice versa, then the formal that can be converted
from is better. (I.e. if the type of Xi can implicitly convert to
the type of Yi, then Xi is better). Similarly, if the type of one
formal can be instantiated to produce the type of another formal, the
type of the more-instantiated formal is better.

Preferred Numeric Conversion Target

Classify the actual and formals by numeric kind. If one formal has the
same kind as the actual but the other does not, the formal with the
same kind is better. Each of the following bullets represents a
different numeric kind for this rule:
- bool(?w), that is, a bool type of any width
- int(?w) or uint(?w), that is, a signed or unsigned integral type
  of any width
- real(?w)
- imag(?w)
- complex(?w)
- all other types
Classify the actual and formals by numeric width. If one formal has
the same numeric width as the actual but the other does not, the
formal with the same width is better. Each of the following bullets
represents a different numeric width for this rule:
- All numeric types that match the default width as well as all bool
  types. This includes bool, bool(?w), int uint real imag
  complex as well as their more specific names int(64) uint(64)
  real(64) imag(64) complex(128)
- All numeric types with 32-bit width: int(32), uint(32),
  real(32), imag(32), complex(64). complex(64) is in this
  category because the real element width is 32 bits.
- All numeric types with 16-bit width: int(16), uint(16)
- All numeric types with 8-bit width: int(8), uint(8)

`max` and `min` functions

This PR adjusts the max and min functions to work with mixed
int/uint. On main before this PR, max(myInt, myUint) produces
real(64), which is problematic (for the same reasons we don't want
myInt + myUint to result in a real(64)). Since this PR enabled
int->uint implicit conversions, these mixed-type min/max calls led to
still different, but surprising, behavior (namely, a negative int might
be larger than the uint). I view this change to max and min as a
generalization of the existing support for comparisons with mixed
int/uint e.g. myInt < myUint.

A Note about Visibility

Previous to this PR, the visibility check was sometimes before and
sometimes after considering how well the arguments matched the formals.
This PR chose to make the visibility check first in the disambiguation
process, rather than last. One reason to do this is that it makes user
code less likely to break in the face of changes to the automatically
used module code.

Warnings for int->uint implicit conversions

This PR includes optional warnings for int->uint conversions that could
have a surprising result. These warnings are triggered by either
--warn-unstable (where it will print that int->uint conversions are
unstable) or by a new flag, --warn-int-uint, which is currently a
developer-only flag.

Implementation Details: Compiler Changes

I have adjusted tryToReplaceWithDirectRangeIterator to call
chpl_direct_range_iter when no stride is specified but to call
chpl_direct_strided_range_iter when a stride is included. This is no
longer strictly necessary. It solved an issue with the heuristic from
PR #19959. However this change seems like an improvement to me (since
it makes the non-strided cases clearer in the AST) and so I left it in.
Several of the properties of a candidate are now computed when needed
and then cached in the ResolutionCandidate.
The PR adjusts scopeResolve to clear modSymsCache at the end of its
run in order to avoid a problem with invalid memory accesses in earlier
versions of this PR.
This PR fixes problems with printing params, including adding a missing
i for imag params and printing :uint for uint params.
Since this PR adds both directions of check to the "can dispatch" rule
(for types that can implicitly convert to each other, such as
bool(?w)), it needed to avoid generousResolutionForErrors allowing
additional implicit conversions from nilable to non-nilable in order to
keep disambiguation working right. So, disambiguateByMatchInner now
saves this global and restores it after the disambiguation process.
This PR includes a partial order checker that verifies that
compareSpecificity is a partial order. This partial order checker
runs with --verify.
testArgMapping and compareSpecificity now distinguish between
"incomparable" and "equal". They return -1 for incomparable, 0 for
equal, 1 for "prefer fn 1" and 2 for "prefer fn 2". We can use the
"equal" case to optimize a few things, but the main reason I made this
change is to just make it clearer in the code that we are dealing with
a partial order (and not a total order).
testArgMapping now normalizes tuple formals and actuals to the value
tuple (not the referential tuple) for the purposes of disambiguation.
Whether an argument is a reference or not is relevant in candidate
selection but not in disambiguation & so this change gives tuples
similar treatment.
testArgMapping now has return statements inside of it. I think this
makes the function cleaner. Relatedly, it now sets a reason argument
for the EXPLAIN calls since they no longer occur inside of it.
Added a workaround for some problems with _getIterator not resolving
correctly. I think it is being added by the compiler in many places and
that causes problems with the visibility change. The workaround is to
consider visibility last (rather than first) in disambiguation when the
call is inside the internal modules or if it is a call to
_getIterator.

Implementation Details: Module Changes

Fixed a problem with dsiAdd in HashedDist not overriding (see commit
4fae8f43dcf5bd515a23dbb308bd0ecc2d11b1d2 for details)
In BlockCycDim, added doDsiIndexToLocale1d to avoid having the function
call itself due to int/uint implicit conversions
Fixed a halt wording for dsiClear not being supported for a domain
Optional changes -- these changes make the standard library more robust
against changes in the rules and so make it easier to do investigation
of disambiguation. However these are not strictly required.
- Adjusted some code in BytesStringCommon to use a cast to clarify the
  type should be int(32)
- un-commented-out param real/imag overloads of + and - in ChapelBase
- used a primitive in some uint comparison overloads (to avoid
  recursive calls in the event the rules change)
tidied up _cond_test to accept all int/uint widths instead of
converting everything to int/uint; added an overload for single that
seemed to be missing.
removed the mixed int/uint operators that call _throwOpError now that
int + uint should result in uint rather than fail.
adjusted int/uint comparison operators to work with any width
Adjusted chpl_build_bounded_range, when both arguments are param,
to preserve the old behavior (use the non-default numeric type if there
is one). Similarly adjusted chpl_compute_low_param_loop_bound and
chpl_compute_high_param_loop_bound. See issue #20545.
Fixed an apparent bug in range.interior where it should be using
abs to check that the offset is OK because the offset can be
negative.
Adjusted range.this to avoid defining inner functions named min and
max since these will shadow the regular min and max. (However
note that internal modules are still using the old shadowing behavior,
as a workaround).
Adjusted chpl__computeTypeForCountMath to account for int->uint
implicit conversions
Adjusted chpl_direct_range_iter to not take in a stride and added
chpl_direct_strided_range_iter for the stride case (this is related
to the tryToReplaceWithDirectRangeIterator compiler change).
Simplified the start, end computation in
chpl_direct_counted_range_iter_helper
Adjusted chpl__addRangeStrides to account for mix of int/uint that is
not just int/uint to account for int->uint coercions.
Added an in intent to the argument to
chpl__initCopy_chpl_rt_localeID_t. I do not know why the error was
not present before.
As discussed above, added mixed int/uint overloads of min and max

Future Work

#20539
#20540
#20543
#20545

Issues Addressed

Resolves https://github.com/Cray/chapel-private/issues/3665
Resolves https://github.com/Cray/chapel-private/issues/3164
Closes #19959
Resolves #7740
Resolves #17756
Resolves #19195
Resolves #19958

Testing and Review

Reviewed by @benharsh and @bradcray - thanks!

gasnet testing (efe453823f5cf890740b60628a184d5cdbc22370)
full local futures testing (efe453823f5cf890740b60628a184d5cdbc22370)
Arkouda works as of 79a25f5fac86a8115a537f3c81efba032d5d6767
CHAMPS as of 6de8ea86c15e38159344ecd3ba5d845280e11e06

Modified Files:
A test/classes/override/override-mix-ambiguity.chpl
A test/classes/override/override-mix-ambiguity.good
A test/compflags/ferguson/warn-int-uint.chpl
A test/compflags/ferguson/warn-int-uint.compopts
A test/compflags/ferguson/warn-int-uint.good
A test/compflags/vass/callstack-internal-modules.skipif
A test/functions/operatorOverloads/shadowing-method-method.chpl
A test/functions/operatorOverloads/shadowing-method-method.good
A test/functions/operatorOverloads/shadowing-method-nonmethod.chpl
A test/functions/operatorOverloads/shadowing-method-nonmethod.good
A test/functions/operatorOverloads/shadowing-nonmethod-method.chpl
A test/functions/operatorOverloads/shadowing-nonmethod-method.good
A test/functions/operatorOverloads/shadowing-nonmethod-nonmethod.chpl
A test/functions/operatorOverloads/shadowing-nonmethod-nonmethod.good
A test/library/standard/AutoMath/min-max-mix.chpl
A test/library/standard/AutoMath/min-max-mix.good
A test/library/standard/LinkedLists/deitz/aseq/test_aseq2-error.prediff
A test/param/diten/paramForDiffTypes3.chpl
A test/param/diten/paramForDiffTypes3.good
A test/studies/hpcc/RA/marybeth/ra-uint-test5.prediff
A test/trivial/deitz/integers/int_uint.prediff
A test/types/coerce/diten/test_uint64_op_int_error.prediff
A test/types/integral/int-uint-compare-test.chpl
A test/types/integral/int-uint-compare-test.good
A test/types/integral/uint-ops.chpl
A test/types/integral/uint-ops.good
A test/types/range/ferguson/range-iteration-mix-types-counted.chpl
A test/types/range/ferguson/range-iteration-mix-types-counted.good
A test/types/range/ferguson/range-iteration-unsigned-counted.chpl
A test/types/range/ferguson/range-iteration-unsigned-counted.good
A test/types/range/ferguson/range-iteration-unsigned-lt.chpl
A test/types/range/ferguson/range-iteration-unsigned-lt.good
A test/types/range/ferguson/range-iteration-unsigned-param.chpl
A test/types/range/ferguson/range-iteration-unsigned-param.good
A test/types/range/ferguson/range-iteration-unsigned.chpl
A test/types/range/ferguson/range-iteration-unsigned.good
A test/types/scalar/hilde/absMinInt.bad
A test/types/sync/vass/ref-sync-2a.bad
A test/types/sync/vass/ref-sync-2a.chpl
A test/types/sync/vass/ref-sync-2a.future
A test/types/sync/vass/ref-sync-2a.good
A test/unstable/warn-int-uint.chpl
A test/unstable/warn-int-uint.good
R test/functions/diten/coerce_param_imag_to_real.bad
R test/functions/diten/coerce_param_imag_to_real.future
R test/functions/operatorOverloads/operatorMethods/secondaryInNonVisibleMod-unrelatedType.chpl
R test/functions/operatorOverloads/operatorMethods/secondaryInNonVisibleMod-unrelatedType.good
R test/functions/resolution/paramUintDispatchesToInt.bad
R test/functions/resolution/paramUintDispatchesToInt.compopts
R test/functions/resolution/paramUintDispatchesToInt.future
R test/functions/resolution/paramUintNoTypeInError.bad
R test/functions/resolution/paramUintNoTypeInError.future
R test/types/integral/uintMinusSmallUint.bad
R test/types/integral/uintMinusSmallUint.future
R test/types/range/hilde/rangeLimitPromotion.future
R test/types/scalar/bradc/overloadbools2.future
R test/types/scalar/bradc/overloadbools3.future
R test/types/scalar/hilde/intUint64.future
R test/types/scalar/hilde/uintUint64.future
R test/types/scalar/vass/paramInt64ToOtherInts.future
R test/types/sync/vass/ref-sync-2.bad
R test/types/sync/vass/ref-sync-2.future
R test/users/vass/div-ceil-on-more-int-types.bad
R test/users/vass/div-ceil-on-more-int-types.future
M compiler/AST/FnSymbol.cpp
M compiler/AST/ForLoop.cpp
M compiler/include/ResolutionCandidate.h
M compiler/include/driver.h
M compiler/include/resolution.h
M compiler/main/driver.cpp
M compiler/passes/scopeResolve.cpp
M compiler/resolution/ResolutionCandidate.cpp
M compiler/resolution/callInfo.cpp
M compiler/resolution/functionResolution.cpp
M compiler/resolution/resolveFunction.cpp
M compiler/resolution/wrappers.cpp
M modules/dists/HashedDist.chpl
M modules/dists/dims/BlockCycDim.chpl
M modules/internal/BytesStringCommon.chpl
M modules/internal/ChapelBase.chpl
M modules/internal/ChapelDistribution.chpl
M modules/internal/ChapelRange.chpl
M modules/internal/LocaleModelHelpRuntime.chpl
M modules/standard/AutoMath.chpl
M test/arrays/promotion/complex_downcast.chpl
M test/classes/assignments/noAssignClass.good
M test/classes/ferguson/forwarding/d-generic.chpl
M test/classes/ferguson/forwarding/d-generic.good
M test/classes/forwarding/forwardOp.bad
M test/classes/override/override-concrete-generic2.chpl
M test/classes/override/override-concrete-generic2.good
M test/classes/override/override-mix.chpl
M test/classes/override/override-mix.good
M test/compflags/vass/callstack-internal-modules.chpl
M test/compflags/vass/callstack-internal-modules.d+s+.good
M test/compflags/vass/callstack-internal-modules.d+s-.good
M test/compflags/vass/callstack-internal-modules.d-s+.good
M test/compflags/vass/callstack-internal-modules.d-s-.good
M test/deprecated/single-direct-access.chpl
M test/deprecated/single-direct-access.good
M test/deprecated/sync-direct-access.chpl
M test/deprecated/sync-direct-access.good
M test/domains/compilerErrors/orderIndex-non-int.chpl
M test/domains/compilerErrors/orderIndex-non-int.good
M test/functions/bradc/intUint3.good
M test/functions/bradc/resolution/lastResort/lastResort.bad
M test/functions/bradc/resolution/smallIntBoolTests/paramNon.good
M test/functions/bradc/resolution/smallIntBoolTests/paramNon3.good
M test/functions/cwailes/disambiguation/dbm_case_M.good
M test/functions/cwailes/disambiguation/dbm_case_N.good
M test/functions/deitz/test_resolve_best_shadowed.good
M test/functions/ferguson/coercions.good
M test/functions/ferguson/subtype-coerce.chpl
M test/functions/jplevyak/subsume-1.good
M test/functions/operatorOverloads/operatorMethods/genericsInstantiationBad.good
M test/functions/operatorOverloads/operatorMethods/genericsInstantiationBad.prediff
M test/functions/operatorOverloads/operatorMethods/nestedMethodBad.good
M test/functions/operatorOverloads/operatorMethods/nestedMethodBad.prediff
M test/functions/resolution/paramUintNoTypeInError.good
M test/library/standard/LinkedLists/deitz/aseq/test_aseq2-error.good
M test/param/diten/paramForDiffTypes2.good
M test/release/examples/benchmarks/hpcc/ptrans.chpl
M test/release/examples/benchmarks/shootout/mandelbrot-fast.chpl
M test/studies/hpcc/RA/marybeth/ra-uint-test1.good
M test/studies/hpcc/RA/marybeth/ra-uint-test4.good
M test/studies/hpcc/RA/marybeth/ra-uint-test5.good
M test/studies/shootout/mandelbrot/ferguson/mandelbrot-tricks.chpl
M test/trivial/bradc/mixedMinMax.good
M test/trivial/deitz/integers/int_uint.good
M test/types/coerce/allNumericsBinary.chpl
M test/types/coerce/allNumericsBinary.good
M test/types/coerce/allNumericsBinaryBigParam.chpl
M test/types/coerce/allNumericsBinaryBigParam.good
M test/types/coerce/allNumericsBinaryBigParamParam.good
M test/types/coerce/allNumericsBinaryGeneric.bad
M test/types/coerce/allNumericsBinaryGeneric.chpl
M test/types/coerce/allNumericsBinaryParam.chpl
M test/types/coerce/allNumericsBinaryParam.good
M test/types/coerce/allNumericsBinaryParamParam.chpl
M test/types/coerce/allNumericsBinaryParamParam.good
M test/types/coerce/allNumericsBinaryRealImagComplex-compiles.chpl
M test/types/coerce/allNumericsBinaryRealImagComplex-compiles.good
M test/types/coerce/allNumericsBinaryRealImagComplex-errors.chpl
M test/types/coerce/allNumericsBinaryRealImagComplex-errors.good
M test/types/coerce/bradc/int2uint.good
M test/types/coerce/diten/test_uint64_op_int_error.good
M test/types/coerce/diten/test_uint64_op_int_error2.good
M test/types/coerce/exponentiationPuzzle.good
M test/types/coerce/ferguson/coercion-dispatch-minimal-modules.chpl
M test/types/coerce/ferguson/coercion-dispatch-minimal-modules.good
M test/types/coerce/intPlusParamUint.good
M test/types/coerce/intPlusReal32.good
M test/types/enum/addEnumUint8.good
M test/types/integral/uintMinusSmallUint.chpl
M test/types/integral/uintMinusSmallUint.good
M test/types/range/hilde/align.chpl
M test/types/range/hilde/alignTypeError1.good
M test/types/range/hilde/alignTypeError2.good
M test/types/range/hilde/count.chpl
M test/types/range/hilde/count.good
M test/types/range/hilde/typeMath.chpl
M test/types/range/hilde/typeMath.good
M test/types/records/ferguson/default-compare-mixed-insn.1.good
M test/types/records/ferguson/default-compare-mixed-insn.2.good
M test/types/records/ferguson/default-compare-mixed-insn.5.good
M test/types/records/ferguson/default-compare-mixed-insn.6.good
M test/types/records/ferguson/default-compare-mixed-insn.prediff
M test/types/scalar/bradc/assignUintNegative.chpl
M test/types/scalar/bradc/assignUintNegative.good
M test/types/scalar/bradc/uint64FnInt.good
M test/types/scalar/hilde/absMinInt.chpl
M test/types/sync/vass/maxmin-on-syncs2.chpl
M test/types/sync/vass/maxmin-on-syncs2.good
M test/users/vass/verify-chpl-divmod-1.chpl
M test/users/vass/verify-chpl-divmod-1.good
M test/users/vass/verify-div-ceil-floor-mod-1.chpl
M test/users/vass/verify-div-ceil-floor-mod-1.good
M test/visibility/except/cannotSeeTertiaryOperator.good
M test/visibility/except/cannotSeeTertiaryOperatorRecord.good
M test/visibility/except/operatorsExceptions/PREDIFF
M test/visibility/except/operatorsExceptions/exceptAddition.good
M test/visibility/except/operatorsExceptions/exceptAnd.good
M test/visibility/except/operatorsExceptions/exceptDivision.good
M test/visibility/except/operatorsExceptions/exceptExponent.good
M test/visibility/except/operatorsExceptions/exceptGreaterThan.good
M test/visibility/except/operatorsExceptions/exceptGreaterThanOrEqual.good
M test/visibility/except/operatorsExceptions/exceptLessThan.good
M test/visibility/except/operatorsExceptions/exceptLessThanOrEqual.good
M test/visibility/except/operatorsExceptions/exceptMod.good
M test/visibility/except/operatorsExceptions/exceptMultiplication.good
M test/visibility/except/operatorsExceptions/exceptNegation.good
M test/visibility/except/operatorsExceptions/exceptNot.good
M test/visibility/except/operatorsExceptions/exceptOr.good
M test/visibility/except/operatorsExceptions/exceptPositiveIdentity.good
M test/visibility/except/operatorsExceptions/exceptShiftLeft.good
M test/visibility/except/operatorsExceptions/exceptShiftRight.good
M test/visibility/except/operatorsExceptions/exceptSubtraction.good
M test/visibility/except/operatorsExceptions/exceptUnaryNot.good
M test/visibility/except/operatorsExceptions/exceptXor.good
M test/visibility/private/functions/privateOperatorError.good
M test/visibility/private/functions/privateOperatorError.prediff
M test/visibility/private/functions/privateOperatorError2.good
M test/visibility/private/functions/privateOperatorError2.prediff
M util/chpl-completion.bash

Compare: Comparing 61476833e94a...e0f13ac5a493 · chapel-lang/chapel · GitHub

Topic		Replies	Views
[design] proposed change to small int -> real/complex conversions Users	0	213	May 4, 2022
128 bit integers - Very Low Priority Users	3	65	May 20, 2024
[Design] Make unary negation of unsigned integers an error? Users	0	156	October 10, 2022
Complex/Imaginary Multiplication Users	3	131	January 16, 2024
[design] should `.size` queries return `int` by convention? Developers	0	298	May 6, 2021