summary refs log tree commit diff stats
path: root/.travis.yml
blob: ebf28750267fd5525e52b56149ed5ab24c5f375d (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
sudo: false
language: c
os:
  - linux
addons:
  apt:
    packages:
    - libcurl4-openssl-dev
    - libsdl1.2-dev
    - libgc-dev
before_script:
  - set -e
  - wget http://nim-lang.org/download/fasm-1.71.39.tgz
  - tar xvf fasm-1.71.39.tgz
  - git clone --depth 1 https://github.com/nim-lang/csources.git
  - cd csources
  - sh build.sh
  - cd ..
  - sed -i -e 's,cc = gcc,cc = clang,' config/nim.cfg
  - export PATH=$(pwd)/bin:$(pwd)/fasm:$PATH
script:
  - nim c koch
  - ./koch boot
  - ./koch boot -d:release
  - nim e install_nimble.nims
  - nim e tests/test_nimscript.nims
  - nimble update
  - nimble install zip
  - nimble install opengl
  - nimble install sdl1
  - nimble install jester@#head
  - nimble install niminst
  - nim c --taintMode:on tests/testament/tester
  - tests/testament/tester --pedantic all
  - ./koch csource
  - ./koch xz
355' href='#n355'>355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
===================================
   Nim Compiler User Guide
===================================

:Author: Andreas Rumpf
:Version: |nimversion|

.. contents::

  "Look at you, hacker. A pathetic creature of meat and bone, panting and
  sweating as you run through my corridors. How can you challenge a perfect,
  immortal machine?"


Introduction
============

This document describes the usage of the *Nim compiler*
on the different supported platforms. It is not a definition of the Nim
programming language (therefore is the `manual <manual.html>`_).

Nim is free software; it is licensed under the
`MIT License <http://www.opensource.org/licenses/mit-license.php>`_.


Compiler Usage
==============

Command line switches
---------------------
Basic command line switches are:

Usage:

.. include:: basicopt.txt

----

Advanced command line switches are:

.. include:: advopt.txt



List of warnings
----------------

Each warning can be activated individually with ``--warning[NAME]:on|off`` or
in a ``push`` pragma.

==========================       ============================================
Name                             Description
==========================       ============================================
CannotOpenFile                   Some file not essential for the compiler's
                                 working could not be opened.
OctalEscape                      The code contains an unsupported octal
                                 sequence.
Deprecated                       The code uses a deprecated symbol.
ConfigDeprecated                 The project makes use of a deprecated config
                                 file.
SmallLshouldNotBeUsed            The letter 'l' should not be used as an
                                 identifier.
EachIdentIsTuple                 The code contains a confusing ``var``
                                 declaration.
ShadowIdent                      A local variable shadows another local
                                 variable of an outer scope.
User                             Some user defined warning.
==========================       ============================================


Verbosity levels
----------------

=====  ============================================
Level  Description
=====  ============================================
0      Minimal output level for the compiler.
1      Displays compilation of all the compiled files, including those imported
       by other modules or through the `compile pragma<#compile-pragma>`_.
       This is the default level.
2      Displays compilation statistics, enumerates the dynamic
       libraries that will be loaded by the final binary and dumps to
       standard output the result of applying `a filter to the source code
       <filters.html>`_ if any filter was used during compilation.
3      In addition to the previous levels dumps a debug stack trace
       for compiler developers.
=====  ============================================


Compile time symbols
--------------------

Through the ``-d:x`` or ``--define:x`` switch you can define compile time
symbols for conditional compilation. The defined switches can be checked in
source code with the `when statement <manual.html#when-statement>`_ and
`defined proc <system.html#defined>`_. The typical use of this switch is to
enable builds in release mode (``-d:release``) where certain safety checks are
omitted for better performance. Another common use is the ``-d:ssl`` switch to
activate `SSL sockets <sockets.html>`_.

Additionally, you may pass a value along with the symbol: ``-d:x=y``
which may be used in conjunction with the `compile time define
pragmas<manual.html#implementation-specific-pragmas-compile-time-define-pragmas>`_
to override symbols during build time.


Configuration files
-------------------

**Note:** The *project file name* is the name of the ``.nim`` file that is
passed as a command line argument to the compiler.


The ``nim`` executable processes configuration files in the following
directories (in this order; later files overwrite previous settings):

1) ``$nim/config/nim.cfg``, ``/etc/nim.cfg`` (UNIX) or ``%NIMROD%/config/nim.cfg`` (Windows). This file can be skipped with the ``--skipCfg`` command line option.
2) ``/home/$user/.config/nim.cfg`` (UNIX) or  ``%APPDATA%/nim.cfg`` (Windows). This file can be skipped with the ``--skipUserCfg`` command line option.
3) ``$parentDir/nim.cfg`` where ``$parentDir`` stands for any parent  directory of the project file's path. These files can be skipped with the ``--skipParentCfg`` command line option.
4) ``$projectDir/nim.cfg`` where ``$projectDir`` stands for the project  file's path. This file can be skipped with the ``--skipProjCfg`` command line option.
5) A project can also have a project specific configuration file named ``$project.nim.cfg`` that resides in the same directory as ``$project.nim``. This file can be skipped with the ``--skipProjCfg`` command line option.


Command line settings have priority over configuration file settings.

The default build of a project is a `debug build`:idx:. To compile a
`release build`:idx: define the ``release`` symbol::

  nim c -d:release myproject.nim


Search path handling
--------------------

Nim has the concept of a global search path (PATH) that is queried to
determine where to find imported modules or include files. If multiple files are
found an ambiguity error is produced.

``nim dump`` shows the contents of the PATH.

However before the PATH is used the current directory is checked for the
file's existence. So if PATH contains ``$lib`` and ``$lib/bar`` and the
directory structure looks like this::

  $lib/x.nim
  $lib/bar/x.nim
  foo/x.nim
  foo/main.nim
  other.nim

And ``main`` imports ``x``, ``foo/x`` is imported. If ``other`` imports ``x``
then both ``$lib/x.nim`` and ``$lib/bar/x.nim`` match and so the compiler
should reject it. Currently however this check is not implemented and instead
the first matching file is used.


Generated C code directory
--------------------------
The generated files that Nim produces all go into a subdirectory called
``nimcache`` in your project directory. This makes it easy to delete all
generated files. Files generated in this directory follow a naming logic which
you can read about in the `Nim Backend Integration document
<backends.html#nimcache-naming-logic>`_.

However, the generated C code is not platform independent. C code generated for
Linux does not compile on Windows, for instance. The comment on top of the
C file lists the OS, CPU and CC the file has been compiled for.


Compilation cache
=================

**Warning**: The compilation cache is still highly experimental!

The ``nimcache`` directory may also contain so called `rod`:idx:
or `symbol files`:idx:. These files are pre-compiled modules that are used by
the compiler to perform `incremental compilation`:idx:. This means that only
modules that have changed since the last compilation (or the modules depending
on them etc.) are re-compiled. However, per default no symbol files are
generated; use the ``--symbolFiles:on`` command line switch to activate them.

Unfortunately due to technical reasons the ``--symbolFiles:on`` needs
to *aggregate* some generated C code. This means that the resulting executable
might contain some cruft even when dead code elimination is turned on. So
the final release build should be done with ``--symbolFiles:off``.

Due to the aggregation of C code it is also recommended that each project
resides in its own directory so that the generated ``nimcache`` directory
is not shared between different projects.


Cross compilation
=================

To cross compile, use for example::

  nim c --cpu:i386 --os:linux --compile_only --gen_script myproject.nim

Then move the C code and the compile script ``compile_myproject.sh`` to your
Linux i386 machine and run the script.

Another way is to make Nim invoke a cross compiler toolchain::

  nim c --cpu:arm --os:linux myproject.nim

For cross compilation, the compiler invokes a C compiler named
like ``$cpu.$os.$cc`` (for example arm.linux.gcc) and the configuration
system is used to provide meaningful defaults. For example for ``ARM`` your
configuration file should contain something like::

  arm.linux.gcc.path = "/usr/bin"
  arm.linux.gcc.exe = "arm-linux-gcc"
  arm.linux.gcc.linkerexe = "arm-linux-gcc"


DLL generation
==============

Nim supports the generation of DLLs. However, there must be only one
instance of the GC per process/address space. This instance is contained in
``nimrtl.dll``. This means that every generated Nim DLL depends
on ``nimrtl.dll``. To generate the "nimrtl.dll" file, use the command::

  nim c -d:release lib/nimrtl.nim

To link against ``nimrtl.dll`` use the command::

  nim c -d:useNimRtl myprog.nim

**Note**: Currently the creation of ``nimrtl.dll`` with thread support has
never been tested and is unlikely to work!


Additional compilation switches
===============================

The standard library supports a growing number of ``useX`` conditional defines
affecting how some features are implemented. This section tries to give a
complete list.

==================   =========================================================
Define               Effect
==================   =========================================================
``release``          Turns off runtime checks and turns on the optimizer.
``useWinAnsi``       Modules like ``os`` and ``osproc`` use the Ansi versions
                     of the Windows API. The default build uses the Unicode
                     version.
``useFork``          Makes ``osproc`` use ``fork`` instead of ``posix_spawn``.
``useNimRtl``        Compile and link against ``nimrtl.dll``.
``useMalloc``        Makes Nim use C's `malloc`:idx: instead of Nim's
                     own memory manager, ableit prefixing each allocation with
                     its size to support clearing memory on reallocation.
                     This only works with ``gc:none``.
``useRealtimeGC``    Enables support of Nim's GC for *soft* realtime
                     systems. See the documentation of the `gc <gc.html>`_
                     for further information.
``nodejs``           The JS target is actually ``node.js``.
``ssl``              Enables OpenSSL support for the sockets module.
``memProfiler``      Enables memory profiling for the native GC.
``uClibc``           Use uClibc instead of libc. (Relevant for Unix-like OSes)
``checkAbi``         When using types from C headers, add checks that compare
                     what's in the Nim file with what's in the C header
                     (requires a C compiler with _Static_assert support, like
                     any C11 compiler)
==================   =========================================================



Additional Features
===================

This section describes Nim's additional features that are not listed in the
Nim manual. Some of the features here only make sense for the C code
generator and are subject to change.


LineDir option
--------------
The ``lineDir`` option can be turned on or off. If turned on the
generated C code contains ``#line`` directives. This may be helpful for
debugging with GDB.


StackTrace option
-----------------
If the ``stackTrace`` option is turned on, the generated C contains code to
ensure that proper stack traces are given if the program crashes or an
uncaught exception is raised.


LineTrace option
----------------
The ``lineTrace`` option implies the ``stackTrace`` option. If turned on,
the generated C contains code to ensure that proper stack traces with line
number information are given if the program crashes or an uncaught exception
is raised.

Debugger option
---------------
The ``debugger`` option enables or disables the *Embedded Nim Debugger*.
See the documentation of endb_ for further information.


Breakpoint pragma
-----------------
The *breakpoint* pragma was specially added for the sake of debugging with
ENDB. See the documentation of `endb <endb.html>`_ for further information.


DynlibOverride
==============

By default Nim's ``dynlib`` pragma causes the compiler to generate
``GetProcAddress`` (or their Unix counterparts)
calls to bind to a DLL. With the ``dynlibOverride`` command line switch this
can be prevented and then via ``--passL`` the static library can be linked
against. For instance, to link statically against Lua this command might work
on Linux::

  nim c --dynlibOverride:lua --passL:liblua.lib program.nim


Backend language options
========================

The typical compiler usage involves using the ``compile`` or ``c`` command to
transform a ``.nim`` file into one or more ``.c`` files which are then
compiled with the platform's C compiler into a static binary. However there
are other commands to compile to C++, Objective-C or Javascript. More details
can be read in the `Nim Backend Integration document <backends.html>`_.


Nim documentation tools
=======================

Nim provides the `doc`:idx: and `doc2`:idx: commands to generate HTML
documentation from ``.nim`` source files. Only exported symbols will appear in
the output. For more details `see the docgen documentation <docgen.html>`_.

Nim idetools integration
========================

Nim provides language integration with external IDEs through the
idetools command. See the documentation of `idetools <idetools.html>`_
for further information.

..
  Nim interactive mode
  ====================

  The Nim compiler supports an interactive mode. This is also known as
  a `REPL`:idx: (*read eval print loop*). If Nim has been built with the
  ``-d:useGnuReadline`` switch, it uses the GNU readline library for terminal
  input management. To start Nim in interactive mode use the command
  ``nim secret``. To quit use the ``quit()`` command. To determine whether an input
  line is an incomplete statement to be continued these rules are used:

  1. The line ends with ``[-+*/\\<>!\?\|%&$@~,;:=#^]\s*$`` (operator symbol followed by optional whitespace).
  2. The line starts with a space (indentation).
  3. The line is within a triple quoted string literal. However, the detection
     does not work if the line contains more than one ``"""``.


Nim for embedded systems
========================

The standard library can be avoided to a point where C code generation
for 16bit micro controllers is feasible. Use the `standalone`:idx: target
(``--os:standalone``) for a bare bones standard library that lacks any
OS features.

To make the compiler output code for a 16bit target use the ``--cpu:avr``
target.

For example, to generate code for an `AVR`:idx: processor use this command::

  nim c --cpu:avr --os:standalone --deadCodeElim:on --genScript x.nim

For the ``standalone`` target one needs to provide
a file ``panicoverride.nim``.
See ``tests/manyloc/standalone/panicoverride.nim`` for an example
implementation.  Additionally, users should specify the
amount of heap space to use with the ``-d:StandaloneHeapSize=<size>``
command line switch.  Note that the total heap size will be
``<size> * sizeof(float64)``.


Nim for realtime systems
========================

See the documentation of Nim's soft realtime `GC <gc.html>`_ for further
information.


Debugging with Nim
==================

Nim comes with its own *Embedded Nim Debugger*. See
the documentation of endb_ for further information.


Optimizing for Nim
==================

Nim has no separate optimizer, but the C code that is produced is very
efficient. Most C compilers have excellent optimizers, so usually it is
not needed to optimize one's code. Nim has been designed to encourage
efficient code: The most readable code in Nim is often the most efficient
too.

However, sometimes one has to optimize. Do it in the following order:

1. switch off the embedded debugger (it is **slow**!)
2. turn on the optimizer and turn off runtime checks
3. profile your code to find where the bottlenecks are
4. try to find a better algorithm
5. do low-level optimizations

This section can only help you with the last item.


Optimizing string handling
--------------------------

String assignments are sometimes expensive in Nim: They are required to
copy the whole string. However, the compiler is often smart enough to not copy
strings. Due to the argument passing semantics, strings are never copied when
passed to subroutines. The compiler does not copy strings that are a result from
a procedure call, because the callee returns a new string anyway.
Thus it is efficient to do:

.. code-block:: Nim
  var s = procA() # assignment will not copy the string; procA allocates a new
                  # string already

However it is not efficient to do:

.. code-block:: Nim
  var s = varA    # assignment has to copy the whole string into a new buffer!

For ``let`` symbols a copy is not always necessary:

.. code-block:: Nim
  let s = varA    # may only copy a pointer if it safe to do so


If you know what you're doing, you can also mark single string (or sequence)
objects as `shallow`:idx:\:

.. code-block:: Nim
  var s = "abc"
  shallow(s) # mark 's' as shallow string
  var x = s  # now might not copy the string!

Usage of ``shallow`` is always safe once you know the string won't be modified
anymore, similar to Ruby's `freeze`:idx:.


The compiler optimizes string case statements: A hashing scheme is used for them
if several different string constants are used. So code like this is reasonably
efficient:

.. code-block:: Nim
  case normalize(k.key)
  of "name": c.name = v
  of "displayname": c.displayName = v
  of "version": c.version = v
  of "os": c.oses = split(v, {';'})
  of "cpu": c.cpus = split(v, {';'})
  of "authors": c.authors = split(v, {';'})
  of "description": c.description = v
  of "app":
    case normalize(v)
    of "console": c.app = appConsole
    of "gui": c.app = appGUI
    else: quit(errorStr(p, "expected: console or gui"))
  of "license": c.license = UnixToNativePath(k.value)
  else: quit(errorStr(p, "unknown variable: " & k.key))
;id=483f28d1cf4baedbce900bc8278e8508127351cc'>^
e25474154 ^



121d4e0fc ^


e25474154 ^



e2f8d9129 ^
e424e13bd ^




fd62116f6 ^
79aaf213d ^


e25474154 ^


e25474154 ^

2900ceae3 ^
4fbba0a65 ^






2900ceae3 ^

4fbba0a65 ^

e2d38a57e ^
4fbba0a65 ^






e25474154 ^
2900ceae3 ^











e25474154 ^
e25474154 ^


4fbba0a65 ^



36247e094 ^
e25474154 ^

e2f8d9129 ^
7bf98411b ^
92e1a21b2 ^
e2f8d9129 ^
92e1a21b2 ^




e2f8d9129 ^


e25474154 ^




674c05f42 ^
e25474154 ^
cacb200ef ^

674c05f42 ^
e25474154 ^
674c05f42 ^
e2f8d9129 ^
b2ad7b30d ^
e25474154 ^
674c05f42 ^

e25474154 ^

674c05f42 ^




4741e8f9a ^
ccd2934e4 ^


e2f8d9129 ^
849208d77 ^



2633e3fb2 ^

849208d77 ^




e2f8d9129 ^
849208d77 ^




e2f8d9129 ^
849208d77 ^

ffcbe19cd ^
849208d77 ^


ffcbe19cd ^
849208d77 ^
ffcbe19cd ^
849208d77 ^
ffcbe19cd ^
99bcc233c ^
740527813 ^
ffcbe19cd ^
dd9ad9e49 ^

2633e3fb2 ^




ffcbe19cd ^
9f38ff0c6 ^

ccd2934e4 ^
849208d77 ^

9c8bc3a24 ^



3cb3813ee ^















e2f8d9129 ^
e25474154 ^



b2ad7b30d ^
12f22ba68 ^
bc2eb0ea9 ^
2900ceae3 ^
e2f8d9129 ^
2900ceae3 ^
e2f8d9129 ^
e25474154 ^

90db9171a ^

e25474154 ^
b2ad7b30d ^
e25474154 ^
95faae2c0 ^

e2f8d9129 ^
95faae2c0 ^

3cb3813ee ^

2900ceae3 ^


e25474154 ^
b2ad7b30d ^


2900ceae3 ^
b2ad7b30d ^
2900ceae3 ^




b2ad7b30d ^



e25474154 ^
e2f8d9129 ^

b2814df5c ^
e25474154 ^


b2814df5c ^








e2f8d9129 ^
b2814df5c ^

b2ad7b30d ^
0171566c9 ^
e25474154 ^
0171566c9 ^
e2f8d9129 ^
e25474154 ^



e2f8d9129 ^
e25474154 ^



e2f8d9129 ^
e25474154 ^



e2f8d9129 ^
e25474154 ^
b2ad7b30d ^
ccd2934e4 ^
e25474154 ^
ccd2934e4 ^

e25474154 ^
ccd2934e4 ^
e2f8d9129 ^
e25474154 ^
ccd2934e4 ^
b2ad7b30d ^
296ef0795 ^

4741e8f9a ^
e2f8d9129 ^
e25474154 ^
b2ad7b30d ^
c7158af75 ^
e25474154 ^

e2f8d9129 ^

90db9171a ^

e2f8d9129 ^





90db9171a ^
e25474154 ^




e2f8d9129 ^
e25474154 ^




e2f8d9129 ^
e25474154 ^
ccd2934e4 ^
b2ad7b30d ^
e25474154 ^

ccd2934e4 ^
e2f8d9129 ^
e25474154 ^
ccd2934e4 ^
b2ad7b30d ^
ccd2934e4 ^
e2f8d9129 ^
e25474154 ^


ccd2934e4 ^
8d99753d6 ^


dab64b5c0 ^
e25474154 ^


ccd2934e4 ^
dab64b5c0 ^
ccd2934e4 ^
e25474154 ^

b2ad7b30d ^
ccd2934e4 ^
b2ad7b30d ^
ccd2934e4 ^
e25474154 ^





b2ad7b30d ^
e25474154 ^


e2f8d9129 ^
e25474154 ^
d25fefc0f ^
e2f8d9129 ^
bc2eb0ea9 ^
4ef96a743 ^
8fd274038 ^
fd62116f6 ^


4ef96a743 ^
0774af169 ^



92e1a21b2 ^
4ef96a743 ^
92e1a21b2 ^
5131b3cea ^
4ef96a743 ^
5131b3cea ^
e25474154 ^
5131b3cea ^
e2f8d9129 ^
fd62116f6 ^
e25474154 ^
e2f8d9129 ^
251c44ff0 ^
e2f8d9129 ^
251c44ff0 ^
e2f8d9129 ^
251c44ff0 ^
e2f8d9129 ^
251c44ff0 ^


e2f8d9129 ^
251c44ff0 ^
e25474154 ^
251c44ff0 ^
e25474154 ^
251c44ff0 ^
e2f8d9129 ^
22dc76a36 ^
289c975d8 ^








22dc76a36 ^
289c975d8 ^
22dc76a36 ^
289c975d8 ^

c7158af75 ^
3a5cf3d63 ^
c7158af75 ^

674c05f42 ^
e25474154 ^
fdde4d3a9 ^
e2f8d9129 ^


e25474154 ^





674c05f42 ^


e25474154 ^



c7158af75 ^






e25474154 ^
5b28d0820 ^
e25474154 ^







38ab30d15 ^










032599c15 ^
e25474154 ^


38ab30d15 ^
e25474154 ^


38ab30d15 ^
a22c1f444 ^
e25474154 ^
121519301 ^

de338526e ^

121519301 ^





0171566c9 ^
121519301 ^


0171566c9 ^


22dc76a36 ^
e25474154 ^
e5bd3b5b9 ^
22dc76a36 ^
b3103c465 ^


22dc76a36 ^

b3103c465 ^
22dc76a36 ^
















e2f8d9129 ^
22dc76a36 ^
e25474154 ^



4fbba0a65 ^
1786e3099 ^
4fbba0a65 ^
e25474154 ^




4fbba0a65 ^

3cb3813ee ^

3a5cf3d63 ^
e25474154 ^
3a5cf3d63 ^
d9d82fb0a ^





3a5cf3d63 ^



5b0d8246f ^
3a5cf3d63 ^

4fbba0a65 ^




e25474154 ^


5b0d8246f ^
e25474154 ^
c7158af75 ^

79aaf213d ^

c7158af75 ^

e25474154 ^
0171566c9 ^
e25474154 ^
0171566c9 ^


e2f8d9129 ^
0171566c9 ^








bec06a064 ^
a22c1f444 ^

3c9e3a6a7 ^
e5bd3b5b9 ^
e25474154 ^




7bf98411b ^
e25474154 ^





e7fe8edab ^
e25474154 ^
ccd2934e4 ^
e25474154 ^
e2f8d9129 ^
e25474154 ^






7bf98411b ^
e25474154 ^




e25474154 ^









e2f8d9129 ^

e25474154 ^
e25474154 ^



eebee0eff ^






3051c52f5 ^
eebee0eff ^




3051c52f5 ^
eebee0eff ^







a22c1f444 ^

a1f677980 ^







46813bbe4 ^








70cf34cbd ^
e25474154 ^
46813bbe4 ^
e25474154 ^
e25474154 ^

46813bbe4 ^
e5bd3b5b9 ^
0171566c9 ^
e25474154 ^

eebee0eff ^
e25474154 ^
5b28d0820 ^
e25474154 ^






ade67f1ab ^
e25474154 ^
5b28d0820 ^
e25474154 ^


eebee0eff ^

e5bd3b5b9 ^

eebee0eff ^
e25474154 ^
a1f677980 ^

e25474154 ^







eebee0eff ^
e25474154 ^
eebee0eff ^
e25474154 ^
eebee0eff ^
e25474154 ^
eebee0eff ^

5b0d8246f ^
eebee0eff ^
e25474154 ^
eebee0eff ^
e25474154 ^
e5bd3b5b9 ^
e25474154 ^
eebee0eff ^
e5bd3b5b9 ^

eebee0eff ^
e25474154 ^
eebee0eff ^
e25474154 ^
eebee0eff ^

e25474154 ^
eebee0eff ^

e25474154 ^

674c05f42 ^
e25474154 ^
ade67f1ab ^
e25474154 ^
5b28d0820 ^
e25474154 ^


eebee0eff ^
e5bd3b5b9 ^

083422407 ^
e25474154 ^
083422407 ^

e25474154 ^





eebee0eff ^
e25474154 ^
a1f677980 ^
e25474154 ^

310faca72 ^
eebee0eff ^





e5bd3b5b9 ^
310faca72 ^
ade67f1ab ^
e5bd3b5b9 ^
310faca72 ^
e5bd3b5b9 ^
ade67f1ab ^
e5bd3b5b9 ^
310faca72 ^


0171566c9 ^
310faca72 ^
ade67f1ab ^
0171566c9 ^

310faca72 ^
0171566c9 ^
7bf98411b ^




0171566c9 ^
e25474154 ^


c7158af75 ^
a22c1f444 ^








c7158af75 ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018


                               
                                         



                                                   
 

                                                              
 
       
                                                                             

                                                                      
 
    
                          
                               
 
                                 

                                                                      


                                                                      


                                              
                                                          
                                            
                                                  

                                                                            
                                                        

                                                                   
                                                                   
  
                                                  






                                                                              
           


                                 
                                                                     






                      

                         
                            
                          
 
                                                        



                             

                                                       
 

                                                                     

                                 
                             
                         
                                                    



                                                             
                                                      
 


                                                                                












                                                       






































                                                                               
                                            
                                          
                        
                                              
                        
                                              
                        
                                              
                        
                                        


                                                     
                          

                                                      


                                                              
 
                                    




                                                          
 
                                            


                                                                             



                                               

                                      


                                                
                  
                                                              



                                  
                                              
                          

                                 

                                             
                     
                      
                                             

                                




                                                                           
                                          
  

                                                           



                                      


                                                                              



                                                  
                                               




                                                     
                         


                                                            


                                                                    

                       
       






                                                             

                                                                           

                                                    
                        






                                                                        
                         











                                                                          
                                                    


                       



                                             
                                                                 

                         
                                        
           
                           
               




                                                


                  




                                                  
                                                              
                 

                    
                                
                    
                                        
                                              
                                     
                                

                                            

                                                                         




                                                                           
 


                                                            
                                                                 



                                                                      

                                       




                                                                   
                                              




                                                                      
                                                

                                                                       
                       


                                                   
                     
                          
                   
                                                                  
                   
                                                                            
                                                      
                   

                                                          




                                                             
                     

                                                   
                                

           



                                                                    















                                                            
                                                              



                      
                                
                                        
                                           
                                     
                                    
                                         
                                   

             

                                                                      
                     
                                         
                                                                   

                        
                                           

                                               

                                          


                                                          
                                                  


                                                            
                                                            
                                                           




                                                              



                                                
            

                                                              
                            


                                             








                                                        
                                               

                                                             
             
                            
               
                              
                                           



                                                                             
                                                        



                                                                             
                                                        



                                                                             
                                                        
                              
             
                
               

                                                                            
                          
           
                                                 
                                              
                                  
             

                        
                                                       
                                       
                                            
                                                          
           

                                         

                                                    

                                                





                                          
                                                                           




                                                                             
                                                 




                                       
                                           
                                                 
                                  
             

               
             
                                           
                                                 
                                  
             
            
                                 


                                  
                                  


                                                        
             


                                 
                                  
             
               

                                                     
                                  
                                  
                                       
             





                                                                        
             


                                          
                                      
                    
                       
                                            
                         
                              
                                                                        


                                                                           
                                     



                                            
                                                   
                                                                   
                        
         
                                       
                          
                                                                 
                                            
                                                                      
                                                                         
                                                     
                                       
                                 
                                            
                
                                      
                             
                                         


                           
                                      
                           
                        
                                  
                        
         
                                                  
                








                                                  
           
                       
         

                                          
                    
                      

                    
                                            
  
                                             


                           





                                                                 


                                                  



                                                                        






                                                    
                                                               
                               







                                                                










                                                                    
                                    


                                         
                                                          


                                   
                                                             
                   
 

                                                                 

                                    





                                                                 
                                             


                                                            


                                                          
 
                                                                     
                                                     
                      


                                            

                   
                                                  
















                                                                          
                        
  



                                                                  
               
                                                                          
                                          




                                                                  

                         

                                                                  
               
                         
                                                                        





                                                   



                                                     
                                                                           

                                                                       




                                                                      


                          
                                                                
                                                                    

                                                                           

                           

                          
                                            
                                                                       
                            


                                                
           








                                                                
 

                                                                   
                                               
                                                         




                                                                            
                           





                              
                 
                                           
                                                                              
                           
                                              






                                 
                                         




                                                 









                                                              

                                                                              
 



                                                       






                                                                    
                                                  




                                                   
                                                  







                                                          

                                                          







                                                                    








                                              
                                   
                                          
                                
                                     

                                                    
 
                  
                                      

                                           
                                  
                                            
                                                             






                                                                     
                                                  
                                 
                                                                      


                             

                                                                          

                                                                         
                    
                           

                                        







                                                       
         
                     
                        
                             
                                       
                                                        

                                                  
                                                                               
                                                                               
                                                                   
               
                                               
                           
                                 
                                                              

                                                                    
                                                                     
                                  
               
                               

                  
                             

                

                                                  
                
                                       
                                                    
                                   
                                                                        


                               
                                                            

                                                                  
                      
                             

                           





                                                                            
             
                                                  
                                

          
 





                                                                             
                                                                     
                          
                           
                                    
 
                                                                
                           
                                    


                                                  
                                
                                       
                                                    

                                        
                                                     
                                                                  




                                                       
           


                                                                 
 








                                                                    
               
#
#
#           The Nimrod Compiler
#        (c) Copyright 2013 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

## This module implements the signature matching for resolving
## the call to overloaded procs, generic procs and operators.

import 
  intsets, ast, astalgo, semdata, types, msgs, renderer, lookups, semtypinst,
  magicsys, condsyms, idents, lexer, options, parampatterns, strutils,
  docgen

type
  TCandidateState* = enum 
    csEmpty, csMatch, csNoMatch

  TCandidate* {.final.} = object 
    exactMatches*: int       # also misused to prefer iters over procs
    genericMatches: int      # also misused to prefer constraints
    subtypeMatches: int
    intConvMatches: int      # conversions to int are not as expensive
    convMatches: int
    state*: TCandidateState
    callee*: PType           # may not be nil!
    calleeSym*: PSym         # may be nil
    calleeScope: int         # may be -1 for unknown scope
    call*: PNode             # modified call
    bindings*: TIdTable      # maps types to types
    baseTypeMatch: bool      # needed for conversions from T to openarray[T]
                             # for example
    proxyMatch*: bool        # to prevent instantiations
    genericConverter*: bool  # true if a generic converter needs to
                             # be instantiated
    inheritancePenalty: int  # to prefer closest father object type
  
  TTypeRelation* = enum      # order is important!
    isNone, isConvertible,
    isIntConv,
    isSubtype,
    isSubrange,              # subrange of the wanted type; no type conversion
                             # but apart from that counts as ``isSubtype``
    isGeneric,
    isFromIntLit,            # conversion *from* int literal; proven safe
    isEqual
    
proc markUsed*(n: PNode, s: PSym)

proc initCandidateAux(c: var TCandidate, callee: PType) {.inline.} = 
  c.exactMatches = 0
  c.subtypeMatches = 0
  c.convMatches = 0
  c.intConvMatches = 0
  c.genericMatches = 0
  c.state = csEmpty
  c.callee = callee
  c.call = nil
  c.baseTypeMatch = false
  c.genericConverter = false
  c.inheritancePenalty = 0

proc initCandidate*(c: var TCandidate, callee: PType) = 
  initCandidateAux(c, callee)
  c.calleeSym = nil
  initIdTable(c.bindings)

proc put(t: var TIdTable, key, val: PType) {.inline.} =
  IdTablePut(t, key, val)

proc initCandidate*(c: var TCandidate, callee: PSym, binding: PNode, 
                    calleeScope = -1) =
  initCandidateAux(c, callee.typ)
  c.calleeSym = callee
  c.calleeScope = calleeScope
  initIdTable(c.bindings)
  if binding != nil and callee.kind in RoutineKinds:
    var typeParams = callee.ast[genericParamsPos]
    for i in 1..min(sonsLen(typeParams), sonsLen(binding)-1):
      var formalTypeParam = typeParams.sons[i-1].typ
      #debug(formalTypeParam)
      put(c.bindings, formalTypeParam, binding[i].typ)

proc newCandidate*(callee: PSym, binding: PNode, calleeScope = -1): TCandidate =
  initCandidate(result, callee, binding, calleeScope)

proc copyCandidate(a: var TCandidate, b: TCandidate) = 
  a.exactMatches = b.exactMatches
  a.subtypeMatches = b.subtypeMatches
  a.convMatches = b.convMatches
  a.intConvMatches = b.intConvMatches
  a.genericMatches = b.genericMatches
  a.state = b.state
  a.callee = b.callee
  a.calleeSym = b.calleeSym
  a.call = copyTree(b.call)
  a.baseTypeMatch = b.baseTypeMatch
  copyIdTable(a.bindings, b.bindings)

proc sumGeneric(t: PType): int =
  var t = t
  while true:
    case t.kind
    of tyGenericInst, tyArray, tyRef, tyPtr, tyDistinct, tyArrayConstr,
        tyOpenArray, tyVarargs, tySet, tyRange, tySequence, tyGenericBody:
      t = t.lastSon
      inc result
    of tyVar:
      # but do not make 'var T' more specific than 'T'!
      t = t.sons[0]
    of tyGenericInvokation, tyTuple:
      result = ord(t.kind == tyGenericInvokation)
      for i in 0 .. <t.len: result += t.sons[i].sumGeneric
      break
    of tyGenericParam, tyExpr, tyStmt, tyTypeDesc, tyTypeClass: break
    else: return 0

proc complexDisambiguation(a, b: PType): int =
  var x, y: int
  for i in 1 .. <a.len: x += a.sons[i].sumGeneric
  for i in 1 .. <b.len: y += b.sons[i].sumGeneric
  result = x - y
  when false:
    proc betterThan(a, b: PType): bool {.inline.} = a.sumGeneric > b.sumGeneric

    if a.len > 1 and b.len > 1:
      let aa = a.sons[1].sumGeneric
      let bb = b.sons[1].sumGeneric
      var a = a
      var b = b
      
      if aa < bb: swap(a, b)
      # all must be better
      for i in 2 .. <min(a.len, b.len):
        if not a.sons[i].betterThan(b.sons[i]): return 0
      # a must be longer or of the same length as b:
      result = a.len - b.len

proc cmpCandidates*(a, b: TCandidate): int =
  result = a.exactMatches - b.exactMatches
  if result != 0: return
  result = a.genericMatches - b.genericMatches
  if result != 0: return
  result = a.subtypeMatches - b.subtypeMatches
  if result != 0: return
  result = a.intConvMatches - b.intConvMatches
  if result != 0: return
  result = a.convMatches - b.convMatches
  if result != 0: return
  if (a.calleeScope != -1) and (b.calleeScope != -1):
    result = a.calleeScope - b.calleeScope
    if result != 0: return
  # the other way round because of other semantics:
  result = b.inheritancePenalty - a.inheritancePenalty
  if result != 0: return
  # prefer more specialized generic over more general generic:
  result = complexDisambiguation(a.callee, b.callee)

proc writeMatches*(c: TCandidate) = 
  Writeln(stdout, "exact matches: " & $c.exactMatches)
  Writeln(stdout, "subtype matches: " & $c.subtypeMatches)
  Writeln(stdout, "conv matches: " & $c.convMatches)
  Writeln(stdout, "intconv matches: " & $c.intConvMatches)
  Writeln(stdout, "generic matches: " & $c.genericMatches)

proc NotFoundError*(c: PContext, n: PNode) =
  # Gives a detailed error message; this is separated from semOverloadedCall,
  # as semOverlodedCall is already pretty slow (and we need this information
  # only in case of an error).
  if c.InCompilesContext > 0: 
    # fail fast:
    GlobalError(n.info, errTypeMismatch, "")
  var result = msgKindToString(errTypeMismatch)
  for i in countup(1, sonsLen(n) - 1):
    var nt = n.sons[i].typ
    if n.sons[i].kind == nkExprEqExpr: 
      add(result, renderTree(n.sons[i].sons[0]))
      add(result, ": ")
      if nt.isNil:
        n.sons[i].sons[1] = c.semOperand(c, n.sons[i].sons[1])
        nt = n.sons[i].sons[1].typ
        n.sons[i].typ = nt
    else:
      if nt.isNil:
        n.sons[i] = c.semOperand(c, n.sons[i])
        nt = n.sons[i].typ
    if nt.kind == tyError: return
    add(result, typeToString(nt))
    if i != sonsLen(n) - 1: add(result, ", ")
  add(result, ')')
  var candidates = ""
  var o: TOverloadIter
  var sym = initOverloadIter(o, c, n.sons[0])
  while sym != nil:
    if sym.kind in RoutineKinds:
      add(candidates, getProcHeader(sym))
      add(candidates, "\n")
    sym = nextOverloadIter(o, c, n.sons[0])
  if candidates != "": 
    add(result, "\n" & msgKindToString(errButExpected) & "\n" & candidates)
  LocalError(n.Info, errGenerated, result)
  
proc typeRel(c: var TCandidate, f, a: PType): TTypeRelation
proc concreteType(c: TCandidate, t: PType): PType = 
  case t.kind
  of tyArrayConstr: 
    # make it an array
    result = newType(tyArray, t.owner)
    addSonSkipIntLit(result, t.sons[0]) # XXX: t.owner is wrong for ID!
    addSonSkipIntLit(result, t.sons[1]) # XXX: semantic checking for the type?
  of tyNil:
    result = nil              # what should it be?
  of tyGenericParam: 
    result = t
    while true: 
      result = PType(idTableGet(c.bindings, t))
      if result == nil:
        break # it's ok, no match
        # example code that triggers it:
        # proc sort[T](cmp: proc(a, b: T): int = cmp)
      if result.kind != tyGenericParam: break
  of tyGenericInvokation:
    InternalError("cannot resolve type: " & typeToString(t))
    result = t
  else:
    result = t                # Note: empty is valid here
  
proc handleRange(f, a: PType, min, max: TTypeKind): TTypeRelation = 
  if a.kind == f.kind: 
    result = isEqual
  else:
    let ab = skipTypes(a, {tyRange})
    let k = ab.kind
    if k == f.kind: result = isSubrange
    elif k == tyInt and f.kind in {tyRange, tyInt8..tyInt64, 
                                   tyUInt..tyUInt64} and
        isIntLit(ab) and ab.n.intVal >= firstOrd(f) and
                         ab.n.intVal <= lastOrd(f):
      # integer literal in the proper range; we want ``i16 + 4`` to stay an
      # ``int16`` operation so we declare the ``4`` pseudo-equal to int16
      result = isFromIntLit
    elif f.kind == tyInt and k in {tyInt8..tyInt32}:
      result = isIntConv
    elif k >= min and k <= max: 
      result = isConvertible
    elif a.kind == tyRange and a.sons[0].kind in {tyInt..tyInt64, 
                                                  tyUInt8..tyUInt32} and
                         a.n[0].intVal >= firstOrd(f) and
                         a.n[1].intVal <= lastOrd(f):
      result = isConvertible
    else: result = isNone
    #elif f.kind == tyInt and k in {tyInt..tyInt32}: result = isIntConv
    #elif f.kind == tyUInt and k in {tyUInt..tyUInt32}: result = isIntConv

proc isConvertibleToRange(f, a: PType): bool =
  # be less picky for tyRange, as that it is used for array indexing:
  if f.kind in {tyInt..tyInt64, tyUInt..tyUInt64} and
     a.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
    result = true
  elif f.kind in {tyFloat..tyFloat128} and
       a.kind in {tyFloat..tyFloat128}:
    result = true

proc handleFloatRange(f, a: PType): TTypeRelation = 
  if a.kind == f.kind: 
    result = isEqual
  else: 
    let ab = skipTypes(a, {tyRange})
    var k = ab.kind
    if k == f.kind: result = isSubrange
    elif isIntLit(ab): result = isConvertible
    elif k >= tyFloat and k <= tyFloat128: result = isConvertible
    else: result = isNone
  
proc isObjectSubtype(a, f: PType): int =
  var t = a
  assert t.kind == tyObject
  var depth = 0
  while t != nil and not sameObjectTypes(f, t): 
    assert t.kind == tyObject
    t = t.sons[0]
    if t == nil: break
    t = skipTypes(t, {tyGenericInst})
    inc depth
  if t != nil:
    result = depth

proc minRel(a, b: TTypeRelation): TTypeRelation = 
  if a <= b: result = a
  else: result = b
  
proc tupleRel(c: var TCandidate, f, a: PType): TTypeRelation =
  result = isNone
  if sameType(f, a):
    result = isEqual
  elif sonsLen(a) == sonsLen(f):
    result = isEqual
    for i in countup(0, sonsLen(f) - 1):
      var m = typeRel(c, f.sons[i], a.sons[i])
      if m < isSubtype: return isNone
      result = minRel(result, m)
    if f.n != nil and a.n != nil:
      for i in countup(0, sonsLen(f.n) - 1):
        # check field names:
        if f.n.sons[i].kind != nkSym: InternalError(f.n.info, "tupleRel")
        elif a.n.sons[i].kind != nkSym: InternalError(a.n.info, "tupleRel")
        else:
          var x = f.n.sons[i].sym
          var y = a.n.sons[i].sym
          if x.name.id != y.name.id: return isNone

proc allowsNil(f: PType): TTypeRelation {.inline.} =
  result = if tfNotNil notin f.flags: isSubtype else: isNone

proc procTypeRel(c: var TCandidate, f, a: PType): TTypeRelation =
  proc inconsistentVarTypes(f, a: PType): bool {.inline.} =
    result = f.kind != a.kind and (f.kind == tyVar or a.kind == tyVar)

  case a.kind
  of tyProc:
    if sonsLen(f) != sonsLen(a): return
    # Note: We have to do unification for the parameters before the
    # return type!
    result = isEqual      # start with maximum; also correct for no
                          # params at all
    for i in countup(1, sonsLen(f)-1):
      var m = typeRel(c, f.sons[i], a.sons[i])
      if m <= isSubtype or inconsistentVarTypes(f.sons[i], a.sons[i]):
        return isNone
      else: result = minRel(m, result)
    if f.sons[0] != nil:
      if a.sons[0] != nil:
        var m = typeRel(c, f.sons[0], a.sons[0])
        # Subtype is sufficient for return types!
        if m < isSubtype or inconsistentVarTypes(f.sons[0], a.sons[0]):
          return isNone
        elif m == isSubtype: result = isConvertible
        else: result = minRel(m, result)
      else:
        return isNone
    elif a.sons[0] != nil:
      return isNone
    if tfNoSideEffect in f.flags and tfNoSideEffect notin a.flags:
      return isNone
    elif tfThread in f.flags and a.flags * {tfThread, tfNoSideEffect} == {}:
      # noSideEffect implies ``tfThread``! XXX really?
      return isNone
    elif f.flags * {tfIterator} != a.flags * {tfIterator}:
      return isNone
    elif f.callconv != a.callconv:
      # valid to pass a 'nimcall' thingie to 'closure':
      if f.callconv == ccClosure and a.callconv == ccDefault:
        result = isConvertible
      else:
        return isNone
    when useEffectSystem:
      if not compatibleEffects(f, a): return isNone
  of tyNil: result = f.allowsNil
  else: nil

proc matchTypeClass(c: var TCandidate, f, a: PType): TTypeRelation =
  result = if matchTypeClass(c.bindings, f, a): isGeneric
           else: isNone

proc typeRangeRel(f, a: PType): TTypeRelation {.noinline.} =
  let
    a0 = firstOrd(a)
    a1 = lastOrd(a)
    f0 = firstOrd(f)
    f1 = lastOrd(f)
  if a0 == f0 and a1 == f1:
    result = isEqual
  elif a0 >= f0 and a1 <= f1:
    result = isConvertible
  elif a0 <= f1 and f0 <= a1:
    # X..Y and C..D overlap iff (X <= D and C <= Y)
    result = isConvertible
  else:
    result = isNone

proc typeRel(c: var TCandidate, f, a: PType): TTypeRelation = 
  # is a subtype of f?
  result = isNone
  assert(f != nil)
  assert(a != nil)
  if a.kind == tyGenericInst and
      skipTypes(f, {tyVar}).kind notin {
        tyGenericBody, tyGenericInvokation,
        tyGenericParam, tyTypeClass}:
    return typeRel(c, f, lastSon(a))
  if a.kind == tyVar and f.kind != tyVar:
    return typeRel(c, f, a.sons[0])
  case f.kind
  of tyEnum: 
    if a.kind == f.kind and sameEnumTypes(f, a): result = isEqual
    elif sameEnumTypes(f, skipTypes(a, {tyRange})): result = isSubtype
  of tyBool, tyChar: 
    if a.kind == f.kind: result = isEqual
    elif skipTypes(a, {tyRange}).kind == f.kind: result = isSubtype
  of tyRange:
    if a.kind == f.kind:
      result = typeRel(c, base(f), base(a))
      # bugfix: accept integer conversions here
      #if result < isGeneric: result = isNone
      if result notin {isNone, isGeneric}:
        result = typeRangeRel(f, a)
    elif skipTypes(f, {tyRange}).kind == a.kind:
      result = isIntConv
    elif isConvertibleToRange(skipTypes(f, {tyRange}), a):
      result = isConvertible  # a convertible to f
  of tyInt:      result = handleRange(f, a, tyInt8, tyInt32)
  of tyInt8:     result = handleRange(f, a, tyInt8, tyInt8)
  of tyInt16:    result = handleRange(f, a, tyInt8, tyInt16)
  of tyInt32:    result = handleRange(f, a, tyInt8, tyInt32)
  of tyInt64:    result = handleRange(f, a, tyInt, tyInt64)
  of tyUInt:     result = handleRange(f, a, tyUInt8, tyUInt32)
  of tyUInt8:    result = handleRange(f, a, tyUInt8, tyUInt8)
  of tyUInt16:   result = handleRange(f, a, tyUInt8, tyUInt16)
  of tyUInt32:   result = handleRange(f, a, tyUInt8, tyUInt32)
  of tyUInt64:   result = handleRange(f, a, tyUInt, tyUInt64)
  of tyFloat:    result = handleFloatRange(f, a)
  of tyFloat32:  result = handleFloatRange(f, a)
  of tyFloat64:  result = handleFloatRange(f, a)
  of tyFloat128: result = handleFloatRange(f, a)
  of tyVar: 
    if a.kind == f.kind: result = typeRel(c, base(f), base(a))
    else: result = typeRel(c, base(f), a)
  of tyArray, tyArrayConstr:
    # tyArrayConstr cannot happen really, but
    # we wanna be safe here
    case a.kind
    of tyArray, tyArrayConstr:
      var fRange = f.sons[0]
      if fRange.kind == tyGenericParam:
        var prev = PType(idTableGet(c.bindings, fRange))
        if prev == nil:
          put(c.bindings, fRange, a.sons[0])
          fRange = a
        else:
          fRange = prev
      result = typeRel(c, f.sons[1], a.sons[1])
      if result < isGeneric: result = isNone
      elif lengthOrd(fRange) != lengthOrd(a): result = isNone
    else: nil
  of tyOpenArray, tyVarargs:
    case a.Kind
    of tyOpenArray, tyVarargs:
      result = typeRel(c, base(f), base(a))
      if result < isGeneric: result = isNone
    of tyArrayConstr: 
      if (f.sons[0].kind != tyGenericParam) and (a.sons[1].kind == tyEmpty): 
        result = isSubtype    # [] is allowed here
      elif typeRel(c, base(f), a.sons[1]) >= isGeneric: 
        result = isSubtype
    of tyArray: 
      if (f.sons[0].kind != tyGenericParam) and (a.sons[1].kind == tyEmpty): 
        result = isSubtype
      elif typeRel(c, base(f), a.sons[1]) >= isGeneric: 
        result = isConvertible
    of tySequence: 
      if (f.sons[0].kind != tyGenericParam) and (a.sons[0].kind == tyEmpty): 
        result = isConvertible
      elif typeRel(c, base(f), a.sons[0]) >= isGeneric: 
        result = isConvertible
    else: nil
  of tySequence:
    case a.Kind
    of tySequence:
      if (f.sons[0].kind != tyGenericParam) and (a.sons[0].kind == tyEmpty):
        result = isSubtype
      else:
        result = typeRel(c, f.sons[0], a.sons[0])
        if result < isGeneric: result = isNone
    of tyNil: result = f.allowsNil
    else: nil
  of tyOrdinal:
    if isOrdinalType(a):
      var x = if a.kind == tyOrdinal: a.sons[0] else: a
      result = typeRel(c, f.sons[0], x)
      if result < isGeneric: result = isNone
  of tyForward: InternalError("forward type in typeRel()")
  of tyNil:
    if a.kind == f.kind: result = isEqual
  of tyTuple: 
    if a.kind == tyTuple: result = tupleRel(c, f, a)
  of tyObject:
    if a.kind == tyObject:
      if sameObjectTypes(f, a): result = isEqual
      else:
        var depth = isObjectSubtype(a, f)
        if depth > 0:
          inc(c.inheritancePenalty, depth)
          result = isSubtype
  of tyDistinct:
    if (a.kind == tyDistinct) and sameDistinctTypes(f, a): result = isEqual
  of tySet: 
    if a.kind == tySet: 
      if (f.sons[0].kind != tyGenericParam) and (a.sons[0].kind == tyEmpty): 
        result = isSubtype
      else: 
        result = typeRel(c, f.sons[0], a.sons[0])
        if result <= isConvertible: 
          result = isNone     # BUGFIX!
  of tyPtr: 
    case a.kind
    of tyPtr: 
      result = typeRel(c, base(f), base(a))
      if result <= isConvertible: result = isNone
    of tyNil: result = f.allowsNil
    else: nil
  of tyRef: 
    case a.kind
    of tyRef:
      result = typeRel(c, base(f), base(a))
      if result <= isConvertible: result = isNone
    of tyNil: result = f.allowsNil
    else: nil
  of tyProc:
    result = procTypeRel(c, f, a)
  of tyPointer: 
    case a.kind
    of tyPointer: result = isEqual
    of tyNil: result = f.allowsNil
    of tyProc:
      if a.callConv != ccClosure: result = isConvertible
    of tyPtr, tyCString: result = isConvertible
    else: nil
  of tyString: 
    case a.kind
    of tyString: result = isEqual
    of tyNil: result = f.allowsNil
    else: nil
  of tyCString:
    # conversion from string to cstring is automatic:
    case a.Kind
    of tyCString: result = isEqual
    of tyNil: result = f.allowsNil
    of tyString: result = isConvertible
    of tyPtr:
      if a.sons[0].kind == tyChar: result = isConvertible
    of tyArray: 
      if (firstOrd(a.sons[0]) == 0) and
          (skipTypes(a.sons[0], {tyRange}).kind in {tyInt..tyInt64}) and
          (a.sons[1].kind == tyChar): 
        result = isConvertible
    else: nil
  of tyEmpty: 
    if a.kind == tyEmpty: result = isEqual
  of tyGenericInst: 
    result = typeRel(c, lastSon(f), a)
  of tyGenericBody: 
    let ff = lastSon(f)
    if ff != nil: result = typeRel(c, ff, a)
  of tyGenericInvokation:
    var x = a.skipGenericAlias
    if x.kind == tyGenericInvokation or f.sons[0].kind != tyGenericBody:
      #InternalError("typeRel: tyGenericInvokation -> tyGenericInvokation")
      # simply no match for now:
      nil
    elif x.kind == tyGenericInst and 
          (f.sons[0] == x.sons[0]) and
          (sonsLen(x) - 1 == sonsLen(f)):
      for i in countup(1, sonsLen(f) - 1):
        if x.sons[i].kind == tyGenericParam:
          InternalError("wrong instantiated type!")
        elif typeRel(c, f.sons[i], x.sons[i]) <= isSubtype: return 
      result = isGeneric
    else:
      result = typeRel(c, f.sons[0], x)
      if result != isNone:
        # we steal the generic parameters from the tyGenericBody:
        for i in countup(1, sonsLen(f) - 1):
          var x = PType(idTableGet(c.bindings, f.sons[0].sons[i - 1]))
          if x == nil or x.kind in {tyGenericInvokation, tyGenericParam}:
            InternalError("wrong instantiated type!")
          put(c.bindings, f.sons[i], x)
  of tyGenericParam, tyTypeClass:
    var x = PType(idTableGet(c.bindings, f))
    if x == nil:
      result = matchTypeClass(c, f, a)
      if result == isGeneric:
        var concrete = concreteType(c, a)
        if concrete == nil:
          result = isNone
        else:
          put(c.bindings, f, concrete)
    elif a.kind == tyEmpty:
      result = isGeneric
    elif x.kind == tyGenericParam:
      result = isGeneric
    else:
      result = typeRel(c, x, a) # check if it fits
  of tyTypeDesc:
    var prev = PType(idTableGet(c.bindings, f))
    if prev == nil:
      if a.kind == tyTypeDesc:
        if f.sonsLen == 0:
          result = isGeneric
        else:
          result = matchTypeClass(c, f, a.sons[0])
        if result == isGeneric:
          put(c.bindings, f, a)
      else:
        result = isNone
    else:
      InternalAssert prev.sonsLen == 1
      result = typeRel(c, prev.sons[0], a)
  of tyExpr, tyStmt:
    result = isGeneric
  of tyProxy:
    result = isEqual
  else: internalError("typeRel: " & $f.kind)
  
proc cmpTypes*(f, a: PType): TTypeRelation = 
  var c: TCandidate
  InitCandidate(c, f)
  result = typeRel(c, f, a)

proc getInstantiatedType(c: PContext, arg: PNode, m: TCandidate, 
                         f: PType): PType = 
  result = PType(idTableGet(m.bindings, f))
  if result == nil: 
    result = generateTypeInstance(c, m.bindings, arg, f)
  if result == nil:
    InternalError(arg.info, "getInstantiatedType")
    result = errorType(c)
  
proc implicitConv(kind: TNodeKind, f: PType, arg: PNode, m: TCandidate, 
                  c: PContext): PNode = 
  result = newNodeI(kind, arg.info)
  if containsGenericType(f):
    if not m.proxyMatch:
      result.typ = getInstantiatedType(c, arg, m, f)
    else:
      result.typ = errorType(c)
  else:
    result.typ = f
  if result.typ == nil: InternalError(arg.info, "implicitConv")
  addSon(result, ast.emptyNode)
  addSon(result, arg)

proc userConvMatch(c: PContext, m: var TCandidate, f, a: PType, 
                   arg: PNode): PNode = 
  result = nil
  for i in countup(0, len(c.converters) - 1): 
    var src = c.converters[i].typ.sons[1]
    var dest = c.converters[i].typ.sons[0]
    # for generic type converters we need to check 'src <- a' before
    # 'f <- dest' in order to not break the unification:
    # see tests/tgenericconverter:
    let srca = typeRel(m, src, a)
    if srca notin {isEqual, isGeneric}: continue
    
    let destIsGeneric = containsGenericType(dest)
    if destIsGeneric:
      dest = generateTypeInstance(c, m.bindings, arg, dest)
    let fdest = typeRel(m, f, dest)
    if fdest in {isEqual, isGeneric}: 
      markUsed(arg, c.converters[i])
      var s = newSymNode(c.converters[i])
      s.typ = c.converters[i].typ
      s.info = arg.info
      result = newNodeIT(nkHiddenCallConv, arg.info, dest)
      addSon(result, s)
      addSon(result, copyTree(arg))
      inc(m.convMatches)
      m.genericConverter = srca == isGeneric or destIsGeneric
      return result

proc localConvMatch(c: PContext, m: var TCandidate, f, a: PType, 
                    arg: PNode): PNode = 
  # arg.typ can be nil in 'suggest':
  if isNil(arg.typ): return nil
  var call = newNodeI(nkCall, arg.info)
  call.add(f.n.copyTree)
  call.add(arg.copyTree)
  result = c.semOverloadedCall(c, call, call, RoutineKinds)
  if result != nil:
    # resulting type must be consistent with the other arguments:
    var r = typeRel(m, f.sons[0], result.typ)
    if r < isGeneric: return nil
    if result.kind == nkCall: result.kind = nkHiddenCallConv
    inc(m.convMatches)
    if r == isGeneric:
      result.typ = getInstantiatedType(c, arg, m, base(f))
    m.baseTypeMatch = true

proc ParamTypesMatchAux(c: PContext, m: var TCandidate, f, a: PType, 
                        arg, argOrig: PNode): PNode =
  var r: TTypeRelation
  let fMaybeExpr = f.skipTypes({tyDistinct})
  if fMaybeExpr.kind == tyExpr:
    if fMaybeExpr.sonsLen == 0:
      r = isGeneric
    else:
      let match = matchTypeClass(m, fMaybeExpr, a)
      if match != isGeneric: r = isNone
      else:
        # XXX: Ideally, this should happen much earlier somewhere near 
        # semOpAux, but to do that, we need to be able to query the 
        # overload set to determine whether compile-time value is expected
        # for the param before entering the full-blown sigmatch algorithm.
        # This is related to the immediate pragma since querying the
        # overload set could help there too.
        var evaluated = c.semConstExpr(c, arg)
        if evaluated != nil:
          r = isGeneric
          arg.typ = newTypeS(tyExpr, c)
          arg.typ.n = evaluated
        
    if r == isGeneric:
      put(m.bindings, f, arg.typ)
  else:
    r = typeRel(m, f, a)
  
  case r
  of isConvertible: 
    inc(m.convMatches)
    result = implicitConv(nkHiddenStdConv, f, copyTree(arg), m, c)
  of isIntConv:
    # I'm too lazy to introduce another ``*matches`` field, so we conflate
    # ``isIntConv`` and ``isIntLit`` here:
    inc(m.intConvMatches)
    result = implicitConv(nkHiddenStdConv, f, copyTree(arg), m, c)
  of isSubtype: 
    inc(m.subtypeMatches)
    result = implicitConv(nkHiddenSubConv, f, copyTree(arg), m, c)
  of isSubrange:
    inc(m.subtypeMatches)
    #result = copyTree(arg)
    result = implicitConv(nkHiddenStdConv, f, copyTree(arg), m, c)
  of isGeneric:
    inc(m.genericMatches)
    if m.calleeSym != nil and m.calleeSym.kind in {skMacro, skTemplate}:
      if f.kind == tyStmt and argOrig.kind == nkDo:
        result = argOrig[bodyPos]
      elif f.kind == tyTypeDesc:
        result = arg
      else:
        result = argOrig
    else:
      result = copyTree(arg)
      result.typ = getInstantiatedType(c, arg, m, f) 
      # BUG: f may not be the right key!
      if skipTypes(result.typ, abstractVar-{tyTypeDesc}).kind in {tyTuple}:
        result = implicitConv(nkHiddenStdConv, f, copyTree(arg), m, c) 
        # BUGFIX: use ``result.typ`` and not `f` here
  of isFromIntLit:
    # too lazy to introduce another ``*matches`` field, so we conflate
    # ``isIntConv`` and ``isIntLit`` here:
    inc(m.intConvMatches, 256)
    result = implicitConv(nkHiddenStdConv, f, copyTree(arg), m, c)
  of isEqual: 
    inc(m.exactMatches)
    result = copyTree(arg)
    if skipTypes(f, abstractVar-{tyTypeDesc}).kind in {tyTuple}:
      result = implicitConv(nkHiddenStdConv, f, copyTree(arg), m, c)
  of isNone:
    # do not do this in ``typeRel`` as it then can't infere T in ``ref T``:
    if a.kind == tyProxy:
      inc(m.genericMatches)
      m.proxyMatch = true
      return copyTree(arg)
    result = userConvMatch(c, m, f, a, arg) 
    # check for a base type match, which supports varargs[T] without []
    # constructor in a call:
    if result == nil and f.kind == tyVarargs:
      if f.n != nil:
        result = localConvMatch(c, m, f, a, arg)
      else:
        r = typeRel(m, base(f), a)
        if r >= isGeneric:
          inc(m.convMatches)
          result = copyTree(arg)
          if r == isGeneric:
            result.typ = getInstantiatedType(c, arg, m, base(f))
          m.baseTypeMatch = true
        else:
          result = userConvMatch(c, m, base(f), a, arg)

proc ParamTypesMatch*(c: PContext, m: var TCandidate, f, a: PType, 
                      arg, argOrig: PNode): PNode =
  if arg == nil or arg.kind notin nkSymChoices:
    result = ParamTypesMatchAux(c, m, f, a, arg, argOrig)
  else: 
    # CAUTION: The order depends on the used hashing scheme. Thus it is
    # incorrect to simply use the first fitting match. However, to implement
    # this correctly is inefficient. We have to copy `m` here to be able to
    # roll back the side effects of the unification algorithm.
    var x, y, z: TCandidate
    initCandidate(x, m.callee)
    initCandidate(y, m.callee)
    initCandidate(z, m.callee)
    x.calleeSym = m.calleeSym
    y.calleeSym = m.calleeSym
    z.calleeSym = m.calleeSym
    var best = -1
    for i in countup(0, sonsLen(arg) - 1): 
      if arg.sons[i].sym.kind in {skProc, skIterator, skMethod, skConverter}: 
        copyCandidate(z, m)
        var r = typeRel(z, f, arg.sons[i].typ)
        if r != isNone: 
          case x.state
          of csEmpty, csNoMatch: 
            x = z
            best = i
            x.state = csMatch
          of csMatch: 
            var cmp = cmpCandidates(x, z)
            if cmp < 0: 
              best = i
              x = z
            elif cmp == 0: 
              y = z           # z is as good as x
    if x.state == csEmpty: 
      result = nil
    elif (y.state == csMatch) and (cmpCandidates(x, y) == 0): 
      if x.state != csMatch: 
        InternalError(arg.info, "x.state is not csMatch") 
      # ambiguous: more than one symbol fits
      result = nil
    else: 
      # only one valid interpretation found:
      markUsed(arg, arg.sons[best].sym)
      result = ParamTypesMatchAux(c, m, f, arg.sons[best].typ, arg.sons[best],
                                  argOrig)

proc setSon(father: PNode, at: int, son: PNode) = 
  if sonsLen(father) <= at: setlen(father.sons, at + 1)
  father.sons[at] = son

# we are allowed to modify the calling node in the 'prepare*' procs:
proc prepareOperand(c: PContext; formal: PType; a: PNode): PNode =
  if formal.kind == tyExpr and formal.len != 1:
    # {tyTypeDesc, tyExpr, tyStmt, tyProxy}:
    # a.typ == nil is valid
    result = a
  elif a.typ.isNil:
    result = c.semOperand(c, a, {efDetermineType})
  else:
    result = a

proc prepareOperand(c: PContext; a: PNode): PNode =
  if a.typ.isNil:
    result = c.semOperand(c, a, {efDetermineType})
  else:
    result = a

proc prepareNamedParam(a: PNode) =
  if a.sons[0].kind != nkIdent:
    var info = a.sons[0].info
    a.sons[0] = newIdentNode(considerAcc(a.sons[0]), info)

proc matchesAux(c: PContext, n, nOrig: PNode,
                m: var TCandidate, marker: var TIntSet) = 
  template checkConstraint(n: expr) {.immediate, dirty.} =
    if not formal.constraint.isNil:
      if matchNodeKinds(formal.constraint, n):
        # better match over other routines with no such restriction:
        inc(m.genericMatches, 100)
      else:
        m.state = csNoMatch
        return

  var
    # iterates over formal parameters
    f = if m.callee.kind != tyGenericBody: 1
        else: 0
    # iterates over the actual given arguments
    a = 1

  m.state = csMatch # until proven otherwise
  m.call = newNodeI(n.kind, n.info)
  m.call.typ = base(m.callee) # may be nil
  var formalLen = m.callee.n.len
  addSon(m.call, copyTree(n.sons[0]))
  var container: PNode = nil # constructed container
  var formal: PSym = nil

  while a < n.len:
    if n.sons[a].kind == nkExprEqExpr:
      # named param
      # check if m.callee has such a param:
      prepareNamedParam(n.sons[a])
      if n.sons[a].sons[0].kind != nkIdent: 
        LocalError(n.sons[a].info, errNamedParamHasToBeIdent)
        m.state = csNoMatch
        return 
      formal = getSymFromList(m.callee.n, n.sons[a].sons[0].ident, 1)
      if formal == nil: 
        # no error message!
        m.state = csNoMatch
        return 
      if ContainsOrIncl(marker, formal.position): 
        # already in namedParams:
        LocalError(n.sons[a].info, errCannotBindXTwice, formal.name.s)
        m.state = csNoMatch
        return 
      m.baseTypeMatch = false
      n.sons[a].sons[1] = prepareOperand(c, formal.typ, n.sons[a].sons[1])
      n.sons[a].typ = n.sons[a].sons[1].typ
      var arg = ParamTypesMatch(c, m, formal.typ, n.sons[a].typ,
                                n.sons[a].sons[1], nOrig.sons[a].sons[1])
      if arg == nil:
        m.state = csNoMatch
        return
      checkConstraint(n.sons[a].sons[1])
      if m.baseTypeMatch: 
        assert(container == nil)
        container = newNodeI(nkBracket, n.sons[a].info)
        addSon(container, arg)
        setSon(m.call, formal.position + 1, container)
        if f != formalLen - 1: container = nil
      else: 
        setSon(m.call, formal.position + 1, arg)
    else:
      # unnamed param
      if f >= formalLen:
        # too many arguments?
        if tfVarArgs in m.callee.flags:
          # is ok... but don't increment any counters...
          # we have no formal here to snoop at:
          n.sons[a] = prepareOperand(c, n.sons[a])
          if skipTypes(n.sons[a].typ, abstractVar-{tyTypeDesc}).kind==tyString:
            addSon(m.call, implicitConv(nkHiddenStdConv, getSysType(tyCString),
                                        copyTree(n.sons[a]), m, c))
          else:
            addSon(m.call, copyTree(n.sons[a]))
        elif formal != nil:
          m.baseTypeMatch = false
          n.sons[a] = prepareOperand(c, formal.typ, n.sons[a])
          var arg = ParamTypesMatch(c, m, formal.typ, n.sons[a].typ,
                                    n.sons[a], nOrig.sons[a])
          if (arg != nil) and m.baseTypeMatch and (container != nil):
            addSon(container, arg)
          else:
            m.state = csNoMatch
            return
        else:
          m.state = csNoMatch
          return
      else:
        if m.callee.n.sons[f].kind != nkSym: 
          InternalError(n.sons[a].info, "matches")
          return
        formal = m.callee.n.sons[f].sym
        if ContainsOrIncl(marker, formal.position): 
          # already in namedParams:
          LocalError(n.sons[a].info, errCannotBindXTwice, formal.name.s)
          m.state = csNoMatch
          return 
        m.baseTypeMatch = false
        n.sons[a] = prepareOperand(c, formal.typ, n.sons[a])
        var arg = ParamTypesMatch(c, m, formal.typ, n.sons[a].typ,
                                  n.sons[a], nOrig.sons[a])
        if arg == nil:
          m.state = csNoMatch
          return
        if m.baseTypeMatch:
          assert(container == nil)
          container = newNodeI(nkBracket, n.sons[a].info)
          addSon(container, arg)
          setSon(m.call, formal.position + 1, 
                 implicitConv(nkHiddenStdConv, formal.typ, container, m, c))
          if f != formalLen - 1: container = nil
        else:
          setSon(m.call, formal.position + 1, arg)
      checkConstraint(n.sons[a])
    inc(a)
    inc(f)

proc semFinishOperands*(c: PContext, n: PNode) =
  # this needs to be called to ensure that after overloading resolution every
  # argument has been sem'checked:
  for i in 1 .. <n.len:
    n.sons[i] = prepareOperand(c, n.sons[i])

proc partialMatch*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
  # for 'suggest' support:
  var marker = initIntSet()
  matchesAux(c, n, nOrig, m, marker)

proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
  var marker = initIntSet()
  matchesAux(c, n, nOrig, m, marker)
  if m.state == csNoMatch: return
  # check that every formal parameter got a value:
  var f = 1
  while f < sonsLen(m.callee.n):
    var formal = m.callee.n.sons[f].sym
    if not ContainsOrIncl(marker, formal.position): 
      if formal.ast == nil:
        if formal.typ.kind == tyVarargs:
          var container = newNodeI(nkBracket, n.info)
          addSon(m.call, implicitConv(nkHiddenStdConv, formal.typ,
                                      container, m, c))
        else:
          # no default value
          m.state = csNoMatch
          break
      else:
        # use default value:
        setSon(m.call, formal.position + 1, copyTree(formal.ast))
    inc(f)

proc argtypeMatches*(c: PContext, f, a: PType): bool = 
  var m: TCandidate
  initCandidate(m, f)
  let res = paramTypesMatch(c, m, f, a, ast.emptyNode, nil)
  #instantiateGenericConverters(c, res, m)
  # XXX this is used by patterns.nim too; I think it's better to not
  # instantiate generic converters for that
  result = res != nil

include suggest