STATUS.devel

#
# This file lists all the existing futures that are categorizes as "bug" or
# "unimplemented feature."
#
# All comments will be stripped out before releasing the final STATUS
#
# To remove comments use: grep -v "^\ *#" STATUS.devel (or 'make STATUS')
#
# To further facilitate generating the final STATUS file, please put the
# names of the future files on a separate line from comments (one future
# per line).  For example:
#
#        # path/to/future/blah.future
#
# If for some reason a .future is omitted prepend the name of the future
# with the 'OMITTED:' and use comments to explain.  For example:
#
#        # OMITTED: path/to/future/blah.future
#        #   b/c it's too difficult to explain
#
#
============================
Chapel Implementation Status
============================

This file contains a list of unimplemented features and known bugs in
the Chapel implementation.  If you find additional bugs and
unimplemented features, or if you would like to request prioritization
of items in this file, please let us know at
chapel-bugs@lists.sourceforge.net or chapel_info@cray.com.  Please
feel encouraged to err on the side of mailing us with any issues you
run into.

# OMITTED: functions/vass/resolution/need-ambiguous-error-1.future
#  b/c it seems a little obscure (it'd be nice to see an example with a non-standard module function)
#
# OMITTED: users/vass/crash1callDestructorsMain.future
#  b/c not investigated
#
# OMITTED: users/csep524/userDefReduceSlim.future
#  b/c multiple errors in the user code and hard to quantify what is wrong
#
# OMITTED: users/npadmana/fftw/testFFTWsegfault.future
# b/c not investigated or diagnosed

General (see also portability section at the bottom of this file)
-----------------------------------------------------------------

- Some error messages are confusing or unhelpful.  If needed, please
  ask us for help with interpreting the message.
  # compflags/bradc/badConfigParamOverride.future
  # sparse/bradc/accumInds-forexpr.future
  # functions/vass/resolution/need-missing-return-error-2.future
  # types/scalar/bradc/index-int.future
- Compiler and runtime and errors may report incorrect line numbers,
  may not be formatted correctly, or may be garbled.  If needed,
  please ask us for help finding the line in question.
  # parsing/vass/newline-in-string-compiletime-1.future
- Errors in unused code may not be reported by the compiler
  # users/kreider/feature_unusedcode.future
- Names in a Chapel program can collide with names used internally.
  # modules/hilde/Writer.future
  # types/records/sungeun/chapelTypes/record_array.future
  # extern/vass/c_sublocid_any.inner-extern.future
- There are several internal memory leaks
  # memory/figueroa/StringLeaks5.future
  - All strings are leaked
  - Privatized domains and arrays (i.e., those that use the standard
    distributions) are leaked
  - Non-default domain maps may be leaked
  - Data associated with iterators may be leaked
  - Data accessed in 'on' and/or 'begin' statements may be leaked
- Separate compilation of Chapel files is not supported.
  # separate_compilation/jturner/array.future
  # separate_compilation/jturner/use_array.future
  # separate_compilation/jturner/use_classextern.future
  # separate_compilation/jturner/use_classextern2.future
  # separate_compilation/jturner/use_fcfunc.future
  # separate_compilation/jturner/use_methodextern.future
  # separate_compilation/jturner/use_methodextern2.future
  # separate_compilation/jturner/use_overload.future
  # separate_compilation/jturner/use_record.future
  # separate_compilation/jturner/use_simplefloat.future
  # separate_compilation/jturner/use_subclass.future
- Back-end compilers may emit warning messages.
- The --gdb flag is only supported for single-locale platforms that
  support gdb.  Please ask us for help if you want to debug a
  multilocale program.


Types, Params, Variables, and Consts
------------------------------------
- Enum types always represented using the smallest integer type
  available, even if the enum values require a larger integer.
  # functions/bradc/resolution/badEnumDispatch.future
- Compile time integer operations on enum values may result in non-param values
  # users/kreider/bug_enum.future
- Cannot define a method on sized types.
  # users/ferguson/int32method.future
- Declaring enum types in a function body can cause compile time errors
  # types/enum/diten/enumDeclInFn.future
  # types/enum/diten/unusedEnumDeclInFn.future
- The default value for the locale type is incorrect.
  # types/locale/bradc/defaultLocaleVal.future
  # multilocale/sungeun/locale_default.future
- Type inferred for a variable initialized to 'nil' is not 'object'
  # classes/deitz/test_infer_nil.future
- Multiple configuration parameters with different types declared in a
  single statement result in an internal compiler error.
  # functions/bradc/paramFnNonParamArgs/multConfigTypes.future
- When setting a config variable that shares an initializer on the
  command line, the new value is incorrectly propagated to the other
  variables.
  # execflags/bradc/configShareInit.future
- When setting a boolean config variable on the command line, using a
  space as the delimiter results in an "Unexpected flag" error.
  # execflags/thomasvandoren/configVarBooleanSpaceAfter.future
- Some assignments to ref variables can cause an internal compiler error.
  # variables/sungeun/refvar-assign-with-cast.future
  # variables/vass/ref-to-const-domain.future
- Assignment of an array slice to a ref variable may fail to reference
  count correctly.
  # variables/vass/ref-to-domains-arrays.future
- Variables that rely on each other for initialization
  and/or type inference may result in an internal compiler error.
  # functions/deitz/test_outoforder.future
- Constant checking is incomplete.
  # domains/bradc/assignConstDom2.future
  # domains/bradc/modDomMethod.future
  # domains/bradc/modDomQuery.future
  # domains/bradc/assignConstDom.future
  # types/records/const-checking/todo-multiple-asgn-errors.future
- Attempting to instantiate a generic class in a type alias context results
  in an unresolved call error.
  # functions/vass/param-formal-in-ctor.future
- Type aliases and enum declarations cannot be declared private/public.
  # visibility/private/typeAlias.future
  # visibility/private/privateEnum.future

Conversions
-----------
- Implicit conversions of enums to uint not supported.
  # types/enum/vass/enum-to-uint-1.future
- Casts and relational operations involving enum constants may fail to
  compile or produce incorrect answers.
  # types/enum/sungeun/cast_enum_weird_2.future
  # types/enum/sungeun/cast_expr_init_1.future
  # types/enum/sungeun/cast_expr_init_2.future
  # types/enum/sungeun/cast_neg_start_1.future
  # types/enum/sungeun/cast_neg_start_2.future
  # types/enum/sungeun/cast_neg_start_3.future
  # types/enum/sungeun/cast_neg_start_oor_1.future
  # types/enum/sungeun/cast_neg_start_oor_2.future
  # functions/diten/param_enum_to_int.future
  # functions/diten/param_enum_to_string.future
- Casts to non-type variables do not result in an error at compile time.
  # expressions/vass/cast-to-non-type-1.future
  # expressions/vass/cast-to-non-type-2.future
- Integer to c_string cast promotes from int to real before cast is performed
  # types/string/thomasvandoren/int-to-c_string.future
- Cast from string to scalar type does not ignore leading white space
  # users/ferguson/cast_to_int_ignore_whitespace.future

Statements and Expressions
--------------------------
- Continue statements in forall and coforall statements not implemented.
  # statements/diten/continueInForall.future
  # statements/sungeun/continue_coforall_label.future
  # statements/sungeun/continue_forall_label.future
- On statement variable declarations are not yet supported.
  E.g., on Locales(1) var x: real;
  # multilocale/sungeun/on_statement_var_decl.future
- The local statement is not well supported.  For example, declaring
  domains (whether explicitly via a declaration or implicitly via
  slicing) results in a runtime seg fault or non-local access error.
  Also, on statements in local blocks should be illegal, but result in
  local execution.
  # multilocale/local/sungeun/local_privatization.future
  # users/jglewis/locClassSegFault.future
- Nested for expressions can cause runtime failure
  # expressions/diten/forExprs.future
- Index variable in for expression can interfere with outer var by same name
  # users/bguarraci/comprehension.future
- Using domain extraction syntax inside a variable declaration causes
  compiler failure instead of a clean error
  # users/bguarraci/domain_extraction.future

Modules
-------
  # OMITTED: modules/sungeun/resolution/module-resolution-issue.future
  # b/c I'm not able to describe it concisely
- Modules that rely on each other for initialization and/or type
  inference may result in an internal compiler error.
  # functions/bradc/resolveConfig.future
  # modules/deitz/test_module_mutual_use.future
  # modules/diten/mutualuse.future
  # modules/diten/mutualuse2.future
  # modules/diten/mutualuse3.future
- User modules that are named the same as standard modules that define
  multiple modules cause compiler errors.
  # modules/bradc/modNamedNewStringBreaks.future
- User modules named the same as types defined internal/standard modules
  can cause multiple definition errors.
  # modules/lydia/object.future
  # modules/lydia/object2.future
- Modules that use another module that uses a begin statement in its
  initialization result in an internal compiler error.
  # parallel/begin/vass/begin-in-module-init.future
- Constructor calls with the same name in different modules are not
  properly resolved.
  # trivial/jturner/module_class_name_clash.future
- Cannot call new for or declare a variable for a type defined in another
  module without explicitly using the module.
  # users/ferguson/module_new.future
  # modules/sungeun/no-use-record.future

Functions and Iterators
-----------------------
- Invalid where clauses may result in an internal compiler error.
  # functions/bradc/resolution/uintParamInWhere.future
- Querying the type of a function is not supported and currently
  returns an internal type.
  # functions/sungeun/type_illegal.future
- Default values for formal arguments do not accept conditional
  expressions.
  # functions/deitz/default/test_default_conditional_expr.future
- Specified argument types that are not types should return a Chapel
  compile time error, but instead they may result in an internal
  compiler error or compile and run.
  # functions/deitz/test_arg_type_is_value_error.future
  # functions/vass/return-type-function-failure.future
- Array-of-array formal argument declarations do not work.
  # arrays/bradc/arrayOfArrayArg.future
- Arrays returned from a var function result in memory corruption.
  # arrays/vass/setter-assigned-to-a-var.future
- Function argument with type tuple of generic class results in a
  compiler assertion.
  # functions/diten/fnGenericTupleArg.future
  # functions/vass/arg-is-tuple-with-generic-class.future
- Actual arguments for formals with out intent do not follow implicit
  conversion rules and must match exactly in type.
  # functions/vass/out-intent-desired.future
- Sync and single vars incorrectly passed to generic ref or const intent
  arguments.
  # types/sync/vass/ref-sync-2.future
  # users/vass/isX/isX.sync-by-const.future
- Sync and single variables in records are not properly copied out
  when the record is passed as an out or inout argument.
  # types/single/sungeun/writeRecordInOutProc.future
  # types/sync/sungeun/writeRecordInOutProc.future
  # types/sync/sungeun/writeRecordOutProc.future
- Parentheses-less function without curly braces enclosing the body
  fail to parse correctly.
  # parsing/vass/parenthesis-less-function-string.future
- Recursive functions that return arrays are not yet supported
  # functions/dinan/array_return_from_recursive.future
- Recursive functions with default argument values may not work.
  # users/csep524/recRetArr.future
- Type and parameter functions are not checked for side effects.
- Param functions can return runtime variables.
  # users/weili/metaprog2.future
- Param functions with explicit return types return the default value
  for the type.
  # functions/vass/paramret-1.future
  # functions/vass/paramret-diten.future
- Var functions returning multiple class types should be illegal, but
  instead they are compiled and result in runtime error.
  # functions/diten/varFnRetClasses.future
  # functions/diten/varFnRetClasses2.future
- Var functions that return local data may not result in an error.
  # functions/deitz/test_var_function_returns_local_via_var_function.future
- Type functions with unambiguous return paths may result in "illegal
  cast" errors.
  # users/weili/typefnbug.future
  # This should be updated when someone knows a little more
  #  about what exactly is going on
- Support for closures and first-class functions is not complete.
  # functions/jturner/first-class-generic-function.future
  # functions/vass/closure-outlives-captured-vars.future
- Recursive iterators may not work correctly.
  # functions/iterators/vass/recursive-iterator-in-expr-context.future
  # studies/madness/aniruddha/madchap/recordBug/test_likepy.future
- Parallel recursive iterators are not supported.
  # functions/iterators/tzakian/par_iter_recursive.future
- Iterators in records cannot change fields in that record.
  # functions/deitz/iterators/test_record_iterator.future
- Iterators with reference variables cause program to crash at runtime
  when compiled with the --baseline flag.
  # studies/shootout/nbody/sidelnik/nbody_iterator_7-refInIterator.future
- Const checking is incorrect for standalone iterator index variables
  # performance/vectorization/vectorizeOnly/constChecking/standaloneConstChecking.future
  # statements/elliot/loops/modifyIndicesStandalone.future
- The implicit 'setter' argument does not work in var iterators.
  # functions/deitz/iterators/iterator_uses_setter.future
  # functions/deitz/iterators/test_promote_var_function_and_iterate.future
- The implicit 'setter' argument used in the where clause of a
  function or method declaration does not work.
  # functions/bharshbarg/setterInWhere.future
  # functions/sungeun/setterFnInWhere.future
  # functions/sungeun/setterMtInWhere.future
- The implicit 'setter' argument passed to other functions may be
  incorrect.
  # functions/vass/setter-passed-to-another-fun.future
- A forall loop with an iteratable expression that does not provide
  leader/follower iterators cause an internal compiler error.
  # functions/iterators/vass/forall-without-leaderfollower.future
- Function return point analysis is conservative.
  # functions/deitz/test_return1.future
  # trivial/preston/gcd.future
- Missing function body at declaration results in an internal compiler
  error.
  # functions/lydia/syntax-error-unclear-message.future
  # functions/lydia/syntax-error-unclear-message2.future
- Function arguments of type 'const ref' should be allowed to have
  default values.
  # functions/sungeun/const_ref_arg_default_value.future
- Formal argument intents on 'this' can result in incorrect function resolution
  or errors.
  # functions/bradc/paramThis/funParamThis3.future


Strings
-------
# OMITTED: associative/thomasvandoren/c_string-to-string.future
# because c_string_copy is not intended to be a user-visible type
- String assignment across locales is sometimes by reference and
  sometimes by value.
  # distributions/bradc/block1Dlocale.future
  # multilocale/diten/needMultiLocales/remoteString3.future
- Casting from complex to string mishandles -0.0i
  # types/complex/diten/complexCastToString.future
- Implicit conversion of a param c_string to string does not work.
  # types/string/diten/c_stringParamInfer.future
- Implicit conversion of c_string to string does not work for ref,
  out, or inout intents.
  # types/string/sungeun/c_string/intents.future
- c_string variable are sometimes copied to remote locales.
  # types/string/sungeun/c_string/multilocale/c_str_on_remote_global_string.future
  # types/string/sungeun/c_string/multilocale/remote_assign_c_string.future
  # types/string/sungeun/c_string/multilocale/remote_assign_global_c_string.future
  # types/string/sungeun/c_string/multilocale/write_c_string.future
- Changes to a string used in a begin statement are not visible from
  the begin body.
  # types/string/sungeun/stringInBegin.future
- Global constant strings are not replicated across locales
  # multilocale/bradc/stringConstRepl.future
- Unable to resolve return type for casts between an enum type and
  string if the enum is declared in the function and the string is
  passed in as a type parameter.
  # types/enum/sungeun/cast_enum_weird_4.future


Tuples
------
- Specifying the type of a tuple of domains or arrays results in a
  runtime error (nil dereference).  It may be possible to work around
  this by implicitly specifying the type by using an assignment at the
  declaration.
  # types/tuple/sungeun/hetTupleWithArray.future
  # types/tuple/sungeun/hetTupleWithArrayInitWithType.future
  # types/tuple/sungeun/hetTupleWithDomain.future
  # types/tuple/sungeun/hetTupleWithDomainInitWithType.future
  # types/tuple/sungeun/homTupleOfArrays.future
  # types/tuple/sungeun/homTupleOfDomains.future
  # types/tuple/claridge/tuple_of_domains.future
  # arrays/vass/tuple-with-array-1.future
- Invalid use of tuple expansion as an expression results in the
  expression evaluating to the first element of the tuple.
  # functions/vass/return-of-tuple-expansion-1.future
  # types/tuple/vass/tuple-expansion-with-parens-1.future
- Tuple expanded list enclosed in parenthesis does not result in a
  tuple.
  # functions/vass/return-of-tuple-expansion-2.future
- Cannot return a non-lvalue tuple from a var function even when
  implicit 'setter' argument is false.
  # functions/bharshbarg/setterBranch.future
  # functions/bharshbarg/setterInFunction.future
- Cannot iterate over heterogeneous tuples
  # types/tuple/sungeun/iteration/heteroTupleOfArrays.future
  # types/tuple/sungeun/iteration/heteroTupleOfDomains.future
  # types/tuple/sungeun/iteration/heteroTupleOfRanges.future
- Cannot iterate over a tuple of iteratable expressions (e.g.,
  iterators).
  # types/tuple/sungeun/iteration/iteratable.future
- Param loops over a tuple of tuples results in an internal compiler error.
  # users/holtbg/tupleOfTupleIteration.future
- Reference tuples do not work.
  # variables/kbrady/ref-in-tuple.future
  # reductions/thomasvandoren/test/TestMini.future
- References cannot be members of classes or records.
  # variables/kbrady/ref-member.future


Ranges
------
- Range operations can result in overflow.
    e.g., (0:uint..5 by -1).length
  # types/range/diten/testRangeSlice.future
  # types/range/diten/testRangeSlice2.future
  # types/range/diten/testRangeSlice3.future
  # types/range/sungeun/length_broken.future
- Ranges that span the entire representable range of the index type
  do not work.
  # types/range/hilde/noCountBigUint.future
- Ranges that are sliced with another range with a different index
  type do not work.
  # types/range/vass/slice-1.future
  # types/range/vass/slice-2.future
  # types/range/vass/slice-unrep-2.future
- Range alignment is not always displayed when printing a range using
  writeln().
  # types/range/vass/writeranges-1.future
- The indexOrder() method on ranges does not work if the unbounded on
  the 'low' end.
  # types/range/vass/indexorder-nofirst-1.future
  # types/range/vass/indexorder-nofirst-2.future
- Param ranges are not supported.
  # users/sidelnik/param_range.future
- Range internals (bounds, stride, and alignment) are not checked for
  overflow when being manipulated.
  # types/range/hilde/needRangeCountType.future
  # types/range/hilde/countError.future
  # types/scalar/hilde/absMinInt.future


Classes, Records, and Unions
----------------------------
- Generic domain types in field declarations result in a compile time
  error.
  # domains/vass/generic-domain-field.future
- Generic types in default value for type fields result in a compile time error
  # functions/typeMethods/genericRecordTypeMethod.future
  # users/ferguson/generic_type_method.future
- Some records with param members fail to compile because the compiler
  does not generate assignment operators for them.
  # functions/ferguson/generic-record-assign.future
  # param/nelson/defaultParamValue.future
- Record and class members that are defined to be array aliases fail
  to compile without an explicitly specified element type.
  # classes/stonea/arrayAliasRecordMember.future
  # studies/hpcc/HPL/stonea/serial/hplExample1.future
- Multiple inheritance as defined in the spec (single base class with
  fields) is not implemented.
  # classes/figueroa/DestructorSubclassing2.future
  # classes/figueroa/DestructorSubclassing3.future
- Declaring members and functions using inherited param or type
  variable may not work.
  # classes/sungeun/inheritance_noUse_param3.future
  # classes/sungeun/inheritance_noUse_param4.future
  # classes/sungeun/inheritance_noUse_typeVar3.future
  # classes/sungeun/inheritance_noUse_typeVar4.future
  # classes/sungeun/inheritance_param1.future
  # classes/sungeun/inheritance_typeVar1.future
- Records returned from functions are destructed incorrectly.
  # types/records/kbrady/return-record.future
- User-defined constructors and destructors are not robust.
  # users/murai/test_nested_class_constructor.future
  # classes/bradc/initialize-secondary.future
  # classes/vass/nested-class-with-user-defined-constructor-1.future
  # classes/constructors/base-class-generic-args.future
- Destructor called on object not constructed in the presence of out
  arguments and early function return.
  # io/lydia/outArgEarlyExitIO.future
  # io/lydia/outArgEarlyExitReader.future
  # io/lydia/outArgEarlyExitWriter.future
- Copy constructors are not properly implemented.
  # types/records/sungeun/constructor2.future
  # users/vass/km/array-of-records-crash-1.explicit-type.future
  # users/vass/km/array-of-records-crash-1.future
- Generic methods called with param actuals may result in "unresolved
  call" error at compile time or incorrect generated code.
  # classes/vass/generic-method-with-param-arg-1.future
  # classes/vass/generic-method-with-param-arg-2.future
  # classes/vass/generic-method-with-param-arg-3.future
- Function resolution may be overly conservative for methods of subclasses.
  # classes/bradc/compilerErrorInMethod/testClear.future
  # classes/diten/subclassMethodCall.future
- Cannot call a standalone function from a class method of the same name
  # functions/lydia/method-iter-resolution-bug.future
- Declaring class members using type aliases may result in unresolved
  type errors.
  # arrays/deitz/part5/test_array_type_field_type.future 
  # classes/diten/type_order_problem.future
  # types/records/bharshbarger/nestedRecordInClass2.future
- Cannot call 'new' on type variables for classes and records
  # types/typedefs/tzakian/classConstructorsFromTypes.future
  # types/typedefs/lydia/new-on-returned-type-alias.future
- Ambiguous definitions of class methods that are overridden in a
  subclass result in an internal compiler error.
  # classes/vass/duplicate-virtual-method-error-2.future
- Classes or records nested in procedures or iterators may result in a
  compile time error.
  # classes/vass/jglewis-class-in-function.future
  # users/ferguson/record-in-iterator.future
- Non-sync arguments to default constructors that expect sync vars are
  not properly coerced to sync type.
  # classes/hannah/coercingIntToSyncIntOnConstructor.future
- Assigning to param class members from constructors may fail to compile
  # classes/constructors/assign-param-segfault.future
- Subclassing uninstantiated generic classes should be prohibited but is not.
- Implicit casting of record parameters not implemented.
  # users/ferguson/recordEquivalence.future
- Array alias arguments to constructors fail to compile.
  # arrays/diten/constructorArrayAliasReindex.future
- Atomics are not passed by ref by default
  # functions/bradc/intents/test_construct_atomic_intent.future
  # functions/iterators/tzakian/atomic_pass_by_ref_leader_follower_iterator.future
- Using a comparison operator with a record and 'nil' results in an
  internal compiler error.
  # types/records/sungeun/recordNotNil1.future
  # types/records/sungeun/recordNotNil2.future
- Records inheritance does not properly expose parent methods.
  # types/records/vass/method-of-parent-record-1.future
- Nested record inheritance results in a compilation error.
  # types/records/vass/nested-record-with-outer-1.future
- Nested record constructor should not need an explicit generic outer
  # users/bguarraci/nested_record.future
- Unused records defined in procedures result in an internal compiler error.
  # types/records/vass/unused-decl-in-proc-1.future
  # types/records/vass/unused-decl-in-proc-2.future
- Recursive records result in function resolution error or internal
  compiler error.
  # types/records/sungeun/recursiveRecord.future
  # arrays/dinan/array_of_records.future
- Records passed by ref intent to dynamically dispatched methods do
  not work.
  # users/kassner/dynDispatchRefRecordArg.future
- Remote records have wide members shallow-copied.  Array members may
  not share the same locale as the containing record violating the
  intended semantics of array copying.
  # types/records/bharshbarger/remoteBlankRecord.future
  # types/records/bharshbarger/remoteInRecord.future
- Classes arguments passed to out, inout, and ref intent formals
  result in a compiler internal error.
  # classes/vass/ref-like-intents/inout-subclass.future
  # classes/vass/ref-like-intents/out-subclass.future
  # classes/vass/ref-like-intents/ref-subclass.future
- Specifying the type when declaring a record variable with const
  fields results in a compile time errors regarding assigning to const
  fields.
  # types/records/const-checking/todo-initializing-typed-var.future
- Default arrays of records with const fields result in compile time
  errors regarding assigning to const fields.
  # types/records/const-checking/scenario-1-array-of-record-with-const-fld.future
  # types/records/const-checking/scenario-2-init-array-of-rec-with-const-fld.future
  # types/records/const-checking/todo-constructors-for-const-rec-fields.future
- Associative domains and arrays of records with const fields result
  in compile time errors regarding assigning to const fields.
  # types/records/const-checking/scenario-3-assoc-dom-of-record-with-const-fld.future
- Comparison (== or !=) of records with array or domain fields result
  in a back-end C compiler error.
  # types/records/bharshbarger/recordArrCmp.future
  # types/records/bharshbarger/recordDomArrCmp.future
- There's no way to determine which field of a union is "active".


Domain Maps, Domains and Arrays
-------------------------------
- Reference counting (used for memory management of domain maps,
  domains, and arrays) may contain bugs.
  # distributions/vass/dmap-var-decl.future
  # studies/graph500/v1/main.future
  # studies/hpcc/HPL/vass/bug.future
- The default domain map is currently a single type for all default domains
  # distributions/bradc/layoutEquality.future
- Distributed domain maps are currently only supported for dense,
  rectangular domains.
- Assignment to domain maps with declared domains not supported for
  all domain map types.
  # distributions/deitz/test_distribution_syntax2.future
- PrivateDist must be used at the top-level scope.
  # distributions/sungeun/misc/useDummyDist.future
- Subset checks on subdomains is not implemented.
- Bounds checks are not implemented for block-cyclic array slices
  # distributions/bradc/blkCyc/blkCycSliceOOB.future
- Bounds checks on index types is not implemented.
- Concurrent slicing of privatized Replicated arrays dereferences nil
  # distributions/dm/hplx.future
- Query expressions on domains and subdomains not supported.
  # domains/vass/domain-arg-query-expr.future
  # functions/vass/arg-is-queried-domain.future
- Iterating over the inner array of arrays where the outer array is
  dmapped BlockDist, results in a remote data access error.
  # distributions/bharshbarg/arrOfArrDmap.future
- Arrays of arrays where the inner arrays vary in size are not supported.
  # arrays/deitz/test_skyline_array.future
  # studies/590o/wk3/02arrOfArr-irregular.future
- Array of array procedure arguments may cause compile time errors
  # users/kreider/bug_array_of_arrays.future
- Array values are permitted to be detupled in an iterator
  # functions/iterators/bradc/badzip/misZipArrays.future
- Arrays of subdomains may not work.
  # users/jglewis/bfs_102207/driver_breadth_first_search.future
- Indexing of array literals may be mis-parsed.
  # arrays/vass/literal-indexing.future
- Arrays declared over domains with negative strides may result in errors.
  # users/weili/arrNegDom-blc.future
  # users/weili/arrNegDom2.future
  # users/weili/arrNegDom3.future
- Array and domain runtime type information is not preserved through
  generic instantiation.
  # arrays/vass/initialization-mapped-1.future
- Modifications to Sparse domains are not thread-safe.
  # domains/sungeun/sparse/forall.future
  # domains/sungeun/sparse/stress.future
- Sparse domain/array slicing is not supported.
  # arrays/stonea/sliceSparseSubdomain.future
  # sparse/bradc/sliceWithDense.future
- Associative domain/array slicing is not supported.
  # users/ferguson/assoc-slice.future
- Associative domain clear() does not reset values of arrays declared
  over the domain.
  # domains/sungeun/assoc/clear.future
- Associative domains with array or domain index types do not work.
  # domains/sungeun/assoc/arrayIdxType.future
  # domains/sungeun/assoc/assocArrayIdxType.future
  # domains/sungeun/assoc/assocDomainIdxType.future
  # domains/sungeun/assoc/domainIdxType.future
  # domains/claridge/domainOfDomains.future
  # puzzles/deitz/puzzle080117.future
- Associative domain literal syntax with a single domain index in
  initializer drops the extra {} and becomes the same as the single
  domain.
  # domains/sungeun/assoc/literalSingleAssocDomain.future
  # domains/sungeun/assoc/literalSingleDomain.future
- Associative arrays with associative array element types result in a
  runtime error.
  # arrays/johnk/associative/recursive.future


Task Parallelism and Synchronization
------------------------------------
- Atomic statements are not implemented.
- Deadlock may occur due to an insufficient number of threads.
  # parallel/cobegin/deitz/test_many_threads.future
  # multilocale/deitz/needMultiLocales/test_big_recursive_on.future
  # multilocale/deitz/needMultiLocales/test_big_recursive_on_begin.future
- Arrays may not be moved to the heap due to begin statements or
  other indirect array element accesses.
  # memory/deitz/test_tricky_heap_case.future
- Sync and single type qualifiers are not disallowed on types that are
  not supported.
  # parallel/single/hilde/jbreitbart.future
  # parallel/sync/diten/syncArrOfSync.future
- Sync variables actuals that used in begin statements may be
  prematurely freed.
  # types/sync/vass/autodestroy-with-begin-1.future
  # types/sync/vass/autodestroy-with-begin-2.future
  # types/sync/vass/autodestroy-with-begin-3.future
  # types/sync/vass/autodestroy-with-begin-ref.future
- Sync variables cannot be used in conditional expressions
  # types/sync/vass/if-sync-int.future
- Default 'const ref' task intent for record does not prevent updates to sync
  variable field in the record from within task.
  # parallel/sync/waynew/record2.future
  # parallel/sync/waynew/record2c.future

Data Parallelism
----------------
  # OMITTED: studies/lsms/shemmy/m-lsms.par-forall.future
  # b/c it is unclear if this is user error or a bug
- Some data parallel statements that are meant to be parallelized in Chapel
  are serialized with a warning message "X has been serialized".  For
  example:
  1. Scans are always serialized.
  # arrays/deitz/parallelism/test_scan_is_parallel.future
  2. Assignments from ranges to multidimensional arrays are always serialized.
  3. Parallel iteration over opaque domains and arrays are always serialized.
   # domains/johnk/associative/literalsWarn.future
- Array promotion/forall/for/scan expressions always evaluate to 1D arrays.
  E.g., f(A) where A promotes f() should result in an array of type:
    [A.domain] f(A(i)).type but instead results in a 1D array
  E.g., [i in D] f(i) should result in an array of type: [D] f(i).type
    but instead results in a 1D array
  # arrays/bradc/inferArrayType.future
  # arrays/tmacd/promotionLosesArrayShape.future
  # reductions/bradc/minmaxlocscan-shape.future
  # sparse/bradc/inferSparseArrayType.future
- Parallel zippered iteration does not perform runtime size/shape checks
  # functions/iterators/bradc/badzip/arrayZipMismatch.future
  # functions/iterators/bradc/badzip/arrayZipMismatch2.future
  # functions/iterators/bradc/badzip/rangeSizeMismatch.future
- Domain promotion results in a race condition.
  # have not futurized yet (see REGRESSIONS domains/sungeun/assoc/minus_equals.chpl)
- Arrays and domains of different ranks can be zippered serially.
- Reductions and scans of arrays of arrays may result in errors.
  # arrays/sungeun/array_of_arrays/bxor_reduce.future
  # arrays/sungeun/array_of_arrays/max_reduce.future
  # arrays/sungeun/array_of_arrays/sum_reduce.future
  # trivial/sidelnik/reduction.future
  # studies/shootout/nbody/sidelnik/nbody_fullreduction.future
- Reduction type definitions nested in classes or records cannot be
  used directly outside of enclosing class or record's scope.
  # users/ferguson/histogram/reductionex_class.future
  # users/ferguson/histogram/reductionex_record.future
- Reductions zippered arrays of mismatched rank result in a compile time error.
  # arrays/diten/reduce2Dwith3D.future
  # arrays/diten/reduce3Dwith2D.future
- Records in reduction classes may results in out-of-bound indexing
  problems.
  # studies/kmeans/kmeansonepassreduction-mystery.future
- Cannot not use an instance of a reduction class for a reduction.
  # reductions/sungeun/count.future
- Whole-domain assignment operations on sparse domains are not all
  serialized as they should be.
  # domains/sungeun/sparse/minus_equals.future
  # domains/sungeun/sparse/plus_equals.future
- Task intents to not work for coforalls and cobegins used in iterators.
  # TODO: are there any futures?  better wording?
- Class or record fields used with ref task intents result in an
  internal compiler error.
  # parallel/taskPar/vass/field-in-task-ref-clause.future
- Iterating over a range where bound+stride overflows the index type
  results in runtime halt
  # users/bguarraci/for_byte.future
- Overloaded xor used in a reduction may result in an internal
  compiler error.
  # reductions/bradc/badoverload.future
- Zipping an associative domain with another iterator in a forall loop can
  result in compile time errors.
  # users/ferguson/assoc_domain_zip_range1.future
  # users/ferguson/assoc_domain_zip_range.future


Standard Modules, Standard Distributions, and Standard Layouts
--------------------------------------------------------------
- On some platforms, the Math module is limited by the back-end C compiler.
- Extended precision math functions are not supported.
  # modules/standard/math/figueroa/extended-precision_math_functions.future
- The BlockCyclic distribution is incomplete.
- Reindexing stridable Cyclic is not fully supported.
  # users/jglewis/test_cyclic_dist.future
- Block and Cyclic domains containing indices near the minimum or
  maximum integral type may overflow.
- Array assignment fails for Block distributions with bounding boxes
  that do not overlap with the bounds of the domain.
  # arrays/sungeun/multilocale/weird_bbox_block.future
- Records with domain map fields do not work.
  # types/records/sungeun/distInRecord.future
  # types/records/sungeun/distInRecordInClass.future


Input and Output
----------------
- Input of whole arrays is not implemented.
  Workaround: use a loop, e.g., for e in A do read(e);
  # types/file/fileIO.future
- Reading of tuple types not supported.
  # io/bradc/readTuple.future
- Printing of multi-dimensional arrays with negative strides may
  result in omitted line break.
  # arrays/vass/print-negstride-bug-1.future
- Printing of replicated arrays may not work properly.
  # io/vass/writeThis-on.future
- Using 'on' in a writeThis() method can lead to a deadlock.
  # multilocale/bradc/needMultiLocales/writeThisUsingOn.future
  # distributions/vass/dmap-writeln-default-value.future
- Calling writeln() of function names should be illegal, but currently
  results in unexpected output, obscure error messages, or internal
  compiler errors.
  # io/sungeun/funcPtr1.future
  # io/sungeun/funcPtr2.future
  # io/sungeun/funcPtr3.future
  # io/sungeun/funcPtr4.future
  # io/sungeun/funcPtr5.future
  # io/sungeun/funcPtr6.future


Optimizations
-------------
# OMITTED: optimizations/rafa/rankChange.future
#  b/c workaround put in place
- Disabling inlining may cause incorrect code to be generated.
  # SEE NIGHTLY BASELINE TESTING NOTES
  # functions/deitz/nested/test_nested_var_iterator3.future
- Module scope runtime constants are not replicated across locales
  # users/bguarraci/const_locale.future


Miscellaneous
-------------
# OMITTED: chpldoc/compflags/alphabetical/classFields.doc.future
#  b/c the future is terse, and I have no idea what is wrong
# OMITTED: memory/shannon/memstatEquals.future
#  b/c it's pretty benign and probably will not cause a problem
# OMITTED: modules/bradc/mainRoutineSurprise/M2.future
#  b/c it's not clear if this is a bug or a feature request
# OMITTED: types/scalar/tmacd/fatal.future
#  b/c it's a bit difficult to describe.
- Nil extern class references not properly handled.
  # users/ferguson/extern_class_test.future
- Extern functions with array arguments cannot have specified 'void' return type
  # users/ibertolacc/void_extern_proc_array.future
- Boolean literals do not preserve their sizes.
  # portability/boolLiteralSizes.future
- Functions from extern includes that have naming conflicts with
  internal functions result in a back-end C compiler error.
  # extern/tzakian/shadow.future
- Functions and variables declared with the same name at the same scope result
  in multiple definition errors
  # users/bguarraci/function_name.future
- An exported function that returns a record results in two versions
  in the generated code.
  # functions/gbt/retRecordMultiDef.future
- Leaving off () when calling exit results in an internal compiler
  error.
  # exits/sungeun/exitWithNoParensNoArgs.future
- Compiler warning mechanism not always type-checked correctly.
  # users/vass/tuple-crash-1.future
- Compiler warning mechanism can result it lost warning if there are
  multiple warnings.
  # trivial/vass/repeated-warning-1.future
- If the -o argument matches an existing directory name <dir>, the
  resulting binary is placed in <dir>/<dir>.tmp.
  # compflags/bradc/dirNameMatchesBin/foo.future
- The usual scoping rules are not followed perfectly during function
  and type resolution.
  # types/records/sungeun/chapelTypes/record_range.future
- Programs requiring non-linear resolution may fail to compile.
  E.g., mutual module uses that access variables across both modules
- Creating many domain types or arrays or tuples types causes the
  compilation time to become unreasonable.
  # arrays/deitz/many/test_many_arrays_of_star_tuples.future
  # arrays/deitz/many/test_many_ranks_of_arithmetic_domains.future
- Types composed of runtime types are not runtime types.
  # arrays/deitz/part3/test_record_of_array_type.future
  # arrays/deitz/part3/test_record_of_domain_type.future
  # arrays/deitz/part6/test_tuple_of_array.future
  # types/tuple/diten/runtimeTypeInTuple.future
  # types/tuple/diten/runtimeTypeInTuple2.future
  # types/tuple/diten/tupleOfArray.future
  # types/tuple/diten/tupleOfArray2.future
  # types/tuple/diten/tupleOfArrayReturnType.future
  # types/tuple/stonea/returnArrayTuple.future
- Comm=ugni network atomic ops fail for vars on tasks=qthreads stacks
  # runtime/gbt/atomic-on-stack.future
- Indexing string literals results in a parse error
  # types/string/sungeun/c_string/substr.future


Performance
-----------
- The body of forall loops over domains with non-default distribution
  are unnecessarily cloned.
  # distributions/bradc/clonedForall.future
- Many provably local variables are unnecessarily widen for
  multilocale execution
  # performance/bradc/refArgIsWide.future
- Task creation for coforall/cobegin statements can be better optimized.
  # multilocale/lydia/checkNumTasks.future
- Mechanisms for program tear-down can be better optimized.
  # parallel/taskPar/sungeun/endCountTest.future


chpldoc
-------
- chpldoc comments that are not closed with using the specified
  comment style are not detected.
  # chpldoc/compflags/comment/badClose.doc.future
- chpldoc generates documentation for some symbols that should not be
  documented
  # chpldoc/basics/main.doc.future
- chpldoc is incorrect or incomplete for some types
  # chpldoc/enum/docConstants.doc.future


Developer
---------
- chpl__autoCopy() and chpl__initCopy() functions and callees cannot
  contain begin statements.
  # parallel/begin/sungeun/autoCopyWithBegin.future
  # parallel/begin/sungeun/initCopyWithBegin.future
- User defined chpl__initCopy() function are ignored in the
  removeUnnecessaryAutoCopyCalls pass.
  # classes/hilde/alwaysOverrideCopyInit.future
- The "no copy" and "no auto destroy" pragmas used with variable
  declarations with specified types result in an internal compiler
  error.
  # trivial/sungeun/pragmas/noCopyNoDestroyPragma.future
  # trivial/sungeun/pragmas/noCopyNoDestroyPragmaArray.future
  # trivial/sungeun/pragmas/noCopyNoDestroyPragmaArrayWithInit.future
  # trivial/sungeun/pragmas/noCopyNoDestroyPragmaWithInit.future


LLVM (experimental)
-------------------

Multi-locale/GASNet executions
------------------------------
- stdin does not work for multi-locale/GASNet executions


Portability
-----------
Linux64:
- On some systems the GMP fac_ui function causes valgrind to issue invalid
  read errors
  # modules/standard/gmp/lydia/gmp_leak.future

Ubuntu:
- Ubuntu 14.04 32-bit (not 64-bit) has a bug in preadv/pwritev support.
  This problem may prevent proper functioning for many of Chapel's IO
  routines. This problem is not present in Ubuntu 12.04 or 14.10 or any
  64-bit version.  See the bug report here:
    https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1309818

OpenSUSE:
- If the site-config package is installed, it sets a CONFIG_SITE environment
  variable which causes some packages in third-party to store their
  libraries in lib64 (vs lib) on 64-bit platforms. Unsetting CONFIG_SITE will
  allow Chapel to build in that case.

cygwin:
- cygwin builds may demonstrate portability issues.
- The qthreads tasking layer is not supported.
- Some utf8 characters have incorrect lengths on cygwin
  # io/ferguson/utf8/widecols-cygwin-copy.future

OS/X:
- For older version (e.g., leopard), the qthreads tasking layer is not
  supported.
- Static linking not supported.

PGI compilers:
- Chapel generated identifier names may be too long.
- Floating point literals of -0.0 may not work as intended.

Intel compilers:
- Floating point literals of -0.0 may not work as intended.
- Static linking may not work.
# OMITTED: studies/lulesh/intelVectBug/lulesh.future
# We suspect that there is a vectorization bug with icc

IEEE floating-point standard conformance:
  The --ieee-float flag is implemented by passing appropriate flags to
  the back-end compiler.  For some compilers, 100% IEEE floating-point
  conformance is not implemented.  In such cases, the --ieee-float
  flag will request the most standard conformant floating-point
  behavior (if such behavior can be identified).


# Not Really Bugs
# OMITTED: modules/standard/LAPACK/dgees.future
# c_ptr(c_char) is the same signedness as the underlying c_char. I believe this
# test is incorrect about this point.
# OMITTED: users/bguarraci/count_type.future
# The range count operator's argument type shouldn't change the range's index type
# OMITTED: users/bguarraci/ref_nil_conjunction.future
# "if (classRef) then ..." is true if not nil, but
# "if (classRef1 && classRef2) then ..." doesn't treat each value as a boolean
# OMITTED: users/bguarraci/sorted_access.future
# iterator or promoted expressions cannot be accessed as arrays without
# assigning to an array first
# OMITTED: users/bguarraci/string_compilation.future
# string(1) is an unresolved call to a function named string, not a cast from
# int to string