Add list.count tests

Author: virendrakabra14

README.md

@@ -1,147 +1,192 @@
 # LPython
 
-LPython is a Python compiler. It is in heavy development, currently in
-pre-alpha stage. Some of the goals of LPython:
-
-* The best possible performance for numerical, array-oriented code
-* Run on all platforms
-* Compile a subset of Python yet be fully compatible with Python
-* Explore designs so that LPython eventually can compile all Python code
-* Fast compilation
-* Excellent user-friendly diagnostic messages: error, warnings, hints, notes,
+LPython is a Python compiler. It is in heavy development, currently in pre-alpha stage. LPython works on Windows, macOS and Linux. Some of the goals of LPython include:
+
+- The best possible performance for numerical, array-oriented code
+- Run on all platforms
+- Compile a subset of Python yet be fully compatible with Python
+- Explore designs so that LPython eventually can compile all Python code
+- Fast compilation
+- Excellent user-friendly diagnostic messages: error, warnings, hints, notes,
   etc.
-* Ahead-of-Time compilation to binaries, plus interactive usage (Jupyter
-  notebook)
-* Transforming Python code to C++, Fortran and other languages
+- Ahead-of-Time compilation to binaries, plus interactive usage (Jupyter notebook)
+- Transforming Python code to C++, Fortran and other languages
 
 And more.
 
 # Installation
 
-LPython works on Windows, macOS and Linux.
+## Step 0: Prerequisites
 
-## Install Conda
+Here is the list of requirements needed to build LPython:
+
+- Python (3.10+)
+- Conda
+
+For Windows, these are additionally required:
+
+- Miniforge Prompt
+- Visual Studio (with "Desktop Development with C++" workload)
+
+Please follow the steps for your desired platform.
+
+## Step 1: Install Conda
+
+This step involves installing Conda using a conda-forge distribution called Miniforge.
 
 Please follow the instructions here to install Conda on your platform:
 
-https://github.com/conda-forge/miniforge/#download
+Miniforge download link (for Linux, MacOS and Windows): https://github.com/conda-forge/miniforge/#download
+
+## Step 2: Setting up
+
+This step involves setting up the required configuration to run the programs in LPython.
 
 ### Linux
 
+Run the below command to install `binutils-dev` package on Linux.
+
 ```bash
 sudo apt install binutils-dev
 ```
 
 ### Windows
-Install Visual Studio (MSVC), for example the version 2022, you can download the
-Community version for free from: https://visualstudio.microsoft.com/downloads/.
 
-Launch the Miniforge prompt from the Desktop.
+Please follow the below steps for Windows:
 
-In the shell, initialize the MSVC compiler using:
+- Install Visual Studio, for example the version 2022.
 
-```bash
-call "C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\VsDevCmd" -arch=x64
-```
+  - You can download the
+    Community version for free from: https://visualstudio.microsoft.com/downloads/.
+  - After installing Visual Studio and running the Visual Studio Installer, you must install the "Desktop Development with C++" workload which will install Visual C++ Compiler (MSVC).
 
-You can optionally test MSVC via:
+- Launch the Miniforge prompt from the Desktop.
 
-```bash
-cl /?
-link /?
-```
+  - It is recommended to use MiniForge instead of Powershell as the main terminal to build and write code for LPython.
 
-Both commands must print several pages of help text.
+- In the MiniForge Prompt, initialize the MSVC compiler using the below command:
 
-## Build LPython
+  ```bash
+  call "C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\VsDevCmd" -arch=x64
+  ```
 
-Clone LPython
+- You can optionally test MSVC via:
 
-```bash
-git clone https://github.com/lcompilers/lpython.git
-cd lpython
-```
+  ```bash
+  cl /?
+  link /?
+  ```
+
+  Both commands must print several pages of help text.
+
+## Step 3: Build LPython
+
+- Clone LPython using the following commands
+
+  ```bash
+  git clone https://github.com/lcompilers/lpython.git
+  cd lpython
+  ```
+
+  You may also use GitHub Desktop to do the same.
 
 ### Linux and MacOS
 
 - Create a Conda environment using the pre-existing file:
 
-```bash
-conda env create -f environment_unix.yml
-conda activate lp
-```
+  ```bash
+  conda env create -f environment_unix.yml
+  conda activate lp
+  ```
 
 - Generate prerequisite files; build in Debug Mode:
 
-```bash
-./build0.sh
-./build1.sh
-```
+  ```bash
+  ./build0.sh
+  ./build1.sh
+  ```
 
 ### Windows
 
 - Create a Conda environment using the pre-existing file:
 
-```bash
-conda env create -f environment_win.yml
-conda activate lp
-```
+  ```bash
+  conda env create -f environment_win.yml
+  conda activate lp
+  ```
 
 - Generate prerequisite files; build in Release Mode:
 
-```bash
-call build0.bat
-call build1.bat
-```
+  ```bash
+  call build0.bat
+  call build1.bat
+  ```
 
 - Tests and examples
 
-```bash
-ctest
-inst\bin\lpython examples\expr2.py
-inst\bin\lpython examples\expr2.py -o a.out
-a.out
-```
+  ```bash
+  ctest
+  inst\bin\lpython examples\expr2.py
+  inst\bin\lpython examples\expr2.py -o a.out
+  a.out
+  ```
 
-- After you update a test case file, you also need to update all the reference results associated with that test case:   
+- Whenever you are updating a test case file, you also need to update all the reference results associated with that test case:
 
-```
-python run_tests.py -u --skip-run-with-dbg
-```
+  ```
+  python run_tests.py -u --skip-run-with-dbg
+  ```
 
 - To see all the options associated with LPython test suite, use:
-```
-python run_tests.py --help
-```
 
-## Tests (Linux or MacOs):
+  ```
+  python run_tests.py --help
+  ```
 
-Run tests:
+## Tests:
 
-```bash
-ctest
-./run_tests.py
-```
+### Linux or MacOS
 
-Run integration tests:
+- Run tests:
 
-```bash
-cd integration_tests
-./run_tests.py
-```
+  ```bash
+  ctest
+  ./run_tests.py
+  ```
+
+- Run integration tests:
+
+  ```bash
+  cd integration_tests
+  ./run_tests.py
+  ```
+
+### Windows
 
-### Speed up Integration Test on Macs
+- Run integration tests
+
+  ```bash
+  python run_tests.py --skip-run-with-dbg
+  ```
+
+- Update reference tests
+
+  ```bash
+  python run_tests.py -u --skip-run-with-dbg
+  ```
+
+## Speed up Integration Tests on MacOS
 
 Integration tests run slowly because Apple checks the hash of each
-executable online before running. You can turn off that feature
-in the Privacy tab of the Security and Privacy item of System
-Preferences, Developer Tools, Terminal.app, "allow the apps below
+executable online before running.
+
+You can turn off that feature in the Privacy tab of the Security and Privacy item of System Preferences > Developer Tools > Terminal.app > "allow the apps below
 to run software locally that does not meet the system's security
 policy."
 
-## Examples (Linux or MacOs)
+## Examples (Linux or MacOS)
 
-You can run the following examples by hand in a terminal:
+You can run the following examples manually in a terminal:
 
 ```bash
 ./src/bin/lpython examples/expr2.py

doc/src/asr/asr_nodes/expression_nodes/IntrinsicFunction.md

@@ -0,0 +1,107 @@
+# IntrinsicFunction
+
+An intrinsic function. An **expr** node.
+
+## Declaration
+
+### Syntax
+
+```
+IntrinsicFunction(expr* args, int intrinsic_id, int overload_id,
+    ttype type, expr? value)
+```
+
+### Arguments
+
+* `args` represents all arguments passed to the function
+* `intrinsic_id` is the unique ID of the generic intrinsic function
+* `overload_id` is the ID of the signature within the given generic function
+* `type` represents the type of the output
+* `value` is an optional compile time value
+
+### Return values
+
+The return value is the expression that the `IntrinsicFunction` represents.
+
+## Description
+
+**IntrinsicFunction** represents an intrinsic function (such as `Abs`,
+`Modulo`, `Sin`, `Cos`, `LegendreP`, `FlipSign`, ...) that either the backend
+or the middle-end (optimizer) needs to have some special logic for. Typically a
+math function, but does not have to be.
+
+IntrinsicFunction is both side-effect-free (no writes to global variables) and
+deterministic (no reads from global variables). They are also elemental: can be
+vectorized over any argument(s). They can be used inside parallel code and
+cached.
+
+The `intrinsic_id` determines the generic function uniquely (`Sin` and `Abs`
+have different number, but `IntegerAbs` and `RealAbs` share the number) and
+`overload_id` uniquely determines the signature starting from 0 for each
+generic function (e.g., `IntegerAbs`, `RealAbs` and `ComplexAbs` can have
+`overload_id` equal to 0, 1 and 2, and `RealSin`, `ComplexSin` can be 0, 1).
+
+Backend use cases: Some architectures have special hardware instructions for
+operations like Sqrt or Sin and if they are faster than a software
+implementation, the backend will use it. This includes the `FlipSign` function
+which is our own "special function" that the optimizer emits for certain
+conditional floating point operations, and the backend emits an efficient bit
+manipulation implementation for architectures that support it.
+
+Middle-end use cases: the middle-end can use the high level semantics to
+simplify, such as `sin(e)**2 + cos(e)**2 -> 1`, or it could approximate
+expressions like `if (abs(sin(x) - 0.5) < 0.3)` with a lower accuracy version
+of `sin`.
+
+We provide ASR -> ASR lowering transformations that substitute the given
+intrinsic function with an ASR implementation using more primitive ASR nodes,
+typically implemented in the surface language (say a `sin` implementation using
+argument reduction and a polynomial fit, or a `sqrt` implementation using a
+general power formula `x**(0.5)`, or `LegendreP(2,x)` implementation using a
+formula `(3*x**2-1)/2`).
+
+This design also makes it possible to allow selecting using command line
+options how certain intrinsic functions should be implemented, for example if
+trigonometric functions should be implemented using our own fast
+implementation, `libm` accurate implementation, we could also call into other
+libraries. These choices should happen at the ASR level, and then the result
+further optimized (such as inlined) as needed.
+
+## Types
+
+The argument types in `args` have the types of the corresponding signature as
+determined by `intrinsic_id`. For example `IntegerAbs` accepts an integer, but
+`RealAbs` accepts a real.
+
+## Examples
+
+The following example code creates `IntrinsicFunction` ASR node:
+
+```fortran
+sin(0.5)
+```
+
+ASR:
+
+```
+(TranslationUnit
+    (SymbolTable
+        1
+        {
+        })
+    [(IntrinsicFunction
+        [(RealConstant
+            0.500000
+            (Real 4 [])
+        )]
+        0
+        0
+        (Real 4 [])
+        (RealConstant 0.479426 (Real 4 []))
+    )]
+)
+```
+
+## See Also
+
+[FunctionCall]()

integration_tests/test_builtin_abs.py

@@ -32,8 +32,8 @@ def test_abs():
 
     b: bool
     b = True
-    assert abs(b) == 1
+    assert abs(i32(b)) == 1
     b = False
-    assert abs(b) == 0
+    assert abs(i32(b)) == 0
 
 test_abs()