⚡ Feature: Variable usage checker #159

New Issue

deavmi · 2023-11-03T19:27:57Z

deavmi commented

2023-11-03 19:27:57 +00:00

What is this?

We can add a component to the dependency generator which tracks the usage of variables. We can then call something like touch(Varable) whenever one is referenced.

This can then increment an entry in a hashmap.

For the quickest implementation for then comparing we should touch(Variable) on declaration as well and not just reference. Therefore we have them all in the hashmap and can find all 0 count ones, (or well, 1 count actually). Anything with a count of 1 is then unused and we can warn the user about this.

Todo

Add hit count mechanism with touch(Variable)
Whenever a variable is referenced, whereever, add code to call touch(Variable)
Have a method which collects all 1-count variables and then returns them as an array of string[] for their identifiers
Compiler integration to print these out at some stage

Tests

Add a unittest for this, can be very basic

Documentation

Document the option typecheck:warnUnusedVars

## What is this? We can add a component to the dependency generator which tracks the usage of variables. We can then call something like `touch(Varable)` whenever one is referenced. This can then increment an entry in a hashmap. For the quickest implementation for then comparing we should `touch(Variable)` on **declaration** as well and **not just** reference. Therefore we have them all in the hashmap and can find all `0` count ones, (or well, `1` count actually). Anything with a count of `1` is then unused and we can warn the user about this. ## Todo - [x] Add hit count mechanism with `touch(Variable)` - [x] Whenever a variable is referenced, whereever, add code to call `touch(Variable)` - [x] Have a method which collects all `1`-count variables and then returns them as an array of `string[]` for their identifiers - [x] Compiler integration to print these out at some stage ### Tests - [x] Add a unittest for this, can be very basic ### Documentation - [x] Document the option `typecheck:warnUnusedVars`

deavmi changed title from ~~### Ideation: Variable usage checker~~ to 🧠 Ideation: Variable usage checker

2023-11-03 19:28:09 +00:00

deavmi added this to the Dependency tree, type-checking and codegen project 2023-11-03 19:28:14 +00:00

deavmi self-assigned this 2023-11-03 19:28:16 +00:00

deavmi added the due date 2023-11-07

2023-11-03 19:28:24 +00:00

deavmi added reference vardec_varass_dependency

2023-11-03 19:28:28 +00:00

deavmi added the

dependency

question

labels 2023-11-03 19:28:38 +00:00

deavmi added spent time 2023-11-03 19:55:17 +00:00

10 minutes

deavmi started working 2023-11-03 19:55:20 +00:00

deavmi changed reference from ~~vardec_varass_dependency~~ to feature/unused_vars_detection

2023-11-03 20:16:36 +00:00

deavmi stopped working 2023-11-03 20:19:20 +00:00

24 minutes

deavmi started working 2023-11-03 20:19:25 +00:00

deavmi commented

2023-11-03 20:19:40 +00:00

Got most of it done, the API and the usage of touch(Variable) where it needs to be.

Got most of it done, the API **and** the usage of `touch(Variable)` where it needs to be.

deavmi stopped working 2023-11-03 20:19:43 +00:00

18 seconds

deavmi added spent time 2023-11-03 21:17:39 +00:00

5 minutes

deavmi started working 2023-11-03 21:17:42 +00:00

deavmi commented

2023-11-03 21:17:58 +00:00

Added a check in dependencyCheck() for unused variables and prints them out

Added a check in `dependencyCheck()` for unused variables and prints them out

deavmi stopped working 2023-11-03 21:37:11 +00:00

19 minutes 29 seconds

deavmi started working 2023-11-03 22:51:04 +00:00

deavmi commented

2023-11-03 22:51:31 +00:00

Let's gooo!

Let's gooo! ![image](/attachments/f068c43f-eccc-49aa-a539-3a3609a6163c)

image.png

232 KiB

deavmi stopped working 2023-11-03 22:51:51 +00:00

47 seconds

deavmi started working 2023-11-04 10:30:23 +00:00

deavmi commented

2023-11-04 10:33:32 +00:00

I think where we print it out, or run through the check is important. That or I have yet to touch(Variable) in the following case:

module unused_vars;

int j;

void thing()
{
    j = 1;
}

As this reports 1 unused variable, but that is NOT true.

I think where we print it out, or run through the check is important. That **or** I have yet to `touch(Variable)` in the following case: ```d module unused_vars; int j; void thing() { j = 1; } ``` As this reports 1 unused variable, but that is **NOT** true.

deavmi commented

2023-11-04 10:55:59 +00:00

I think where we print it out, or run through the check is important. That or I have yet to touch(Variable) in the following case:
module unused_vars;

int j;

void thing()
{
    j = 1;
}
As this reports 1 unused variable, but that is NOT true.

I think I am doing this stuff too early?

> I think where we print it out, or run through the check is important. That **or** I have yet to `touch(Variable)` in the following case: > > ```d > module unused_vars; > > int j; > > void thing() > { > j = 1; > } > ``` > > As this reports 1 unused variable, but that is **NOT** true. I think I am doing this stuff too early?

deavmi commented

2023-11-04 11:02:37 +00:00

I think where we print it out, or run through the check is important. That or I have yet to touch(Variable) in the following case:
module unused_vars;

int j;

void thing()
{
    j = 1;
}
As this reports 1 unused variable, but that is NOT true.
I think I am doing this stuff too early?

Problem demystified 🔎

I found it, we use a seperate DNodeGenerator for the functions. We need some over-arching mechanism to group these altogether. Perhaps, placing the touching mechanism in the TypeChecker as a place-of-precense that both seperate instances of DNodeGenerator can then touch on.

> > I think where we print it out, or run through the check is important. That **or** I have yet to `touch(Variable)` in the following case: > > > > ```d > > module unused_vars; > > > > int j; > > > > void thing() > > { > > j = 1; > > } > > ``` > > > > As this reports 1 unused variable, but that is **NOT** true. > > I think I am doing this stuff too early? ## Problem demystified 🔎 I found it, we use a seperate `DNodeGenerator` for the functions. We need some over-arching mechanism to group these altogether. Perhaps, placing the touching mechanism in the `TypeChecker` as a place-of-precense that both seperate instances of `DNodeGenerator` can then touch on.

deavmi stopped working 2023-11-04 11:02:42 +00:00

32 minutes 19 seconds

deavmi added spent time 2023-11-04 11:10:52 +00:00

10 minutes

deavmi started working 2023-11-04 11:10:54 +00:00

deavmi commented

2023-11-04 11:11:09 +00:00

I think where we print it out, or run through the check is important. That or I have yet to touch(Variable) in the following case:
module unused_vars;

int j;

void thing()
{
    j = 1;
}
As this reports 1 unused variable, but that is NOT true.
I think I am doing this stuff too early?
Problem demystified 🔎

I found it, we use a seperate DNodeGenerator for the functions. We need some over-arching mechanism to group these altogether. Perhaps, placing the touching mechanism in the TypeChecker as a place-of-precense that both seperate instances of DNodeGenerator can then touch on.

I got this implemented and it works!

> > > I think where we print it out, or run through the check is important. That **or** I have yet to `touch(Variable)` in the following case: > > > > > > ```d > > > module unused_vars; > > > > > > int j; > > > > > > void thing() > > > { > > > j = 1; > > > } > > > ``` > > > > > > As this reports 1 unused variable, but that is **NOT** true. > > > > I think I am doing this stuff too early? > > ## Problem demystified 🔎 > > I found it, we use a seperate `DNodeGenerator` for the functions. We need some over-arching mechanism to group these altogether. Perhaps, placing the touching mechanism in the `TypeChecker` as a place-of-precense that both seperate instances of `DNodeGenerator` can then touch on. > > I got this implemented and it works! ![image](/attachments/861d47fd-306a-4f1f-b595-9aaf306c1ce7)

image.png

60 KiB

deavmi commented

2023-11-04 11:58:01 +00:00

What is this?

We can add a component to the dependency generator which tracks the usage of variables. We can then call something like touch(Varable) whenever one is referenced.

This can then increment an entry in a hashmap.

For the quickest implementation for then comparing we should touch(Variable) on declaration as well and not just reference. Therefore we have them all in the hashmap and can find all 0 count ones, (or well, 1 count actually). Anything with a count of 1 is then unused and we can warn the user about this.

Todo

Add hit count mechanism with touch(Variable)

Whenever a variable is referenced, whereever, add code to call touch(Variable)

Have a method which collects all 1-count variables and then returns them as an array of string[] for their identifiers

Compiler integration to print these out at some stage

Tests

Add a unittest for this, can be very basic

Documentation

Document the option typecheck:warnUnusedVars

Compiler integration added with a config variable

> ## What is this? > > We can add a component to the dependency generator which tracks the usage of variables. We can then call something like `touch(Varable)` whenever one is referenced. > > This can then increment an entry in a hashmap. > > For the quickest implementation for then comparing we should `touch(Variable)` on **declaration** as well and **not just** reference. Therefore we have them all in the hashmap and can find all `0` count ones, (or well, `1` count actually). Anything with a count of `1` is then unused and we can warn the user about this. > > ## Todo > > - [x] Add hit count mechanism with `touch(Variable)` > - [x] Whenever a variable is referenced, whereever, add code to call `touch(Variable)` > - [x] Have a method which collects all `1`-count variables and then returns them as an array of `string[]` for their identifiers > - [ ] Compiler integration to print these out at some stage > > ### Tests > > - [ ] Add a unittest for this, can be very basic > > ### Documentation > > - [ ] Document the option `typecheck:warnUnusedVars` Compiler integration added with a config variable

deavmi stopped working 2023-11-04 11:58:06 +00:00

47 minutes 12 seconds

deavmi started working 2023-11-04 13:51:31 +00:00

deavmi removed the

question

label 2023-11-04 13:53:05 +00:00

deavmi changed title from ~~🧠 Ideation: Variable usage checker~~ to ⚡ Feature: Variable usage checker

2023-11-04 13:53:17 +00:00

deavmi stopped working 2023-11-04 13:53:27 +00:00

1 minute 57 seconds

deavmi started working 2023-11-04 20:56:22 +00:00

deavmi stopped working 2023-11-04 20:57:35 +00:00

1 minute 13 seconds

deavmi started working 2023-11-05 14:25:11 +00:00

deavmi commented

2023-11-05 14:38:05 +00:00

What is this?

We can add a component to the dependency generator which tracks the usage of variables. We can then call something like touch(Varable) whenever one is referenced.

This can then increment an entry in a hashmap.

For the quickest implementation for then comparing we should touch(Variable) on declaration as well and not just reference. Therefore we have them all in the hashmap and can find all 0 count ones, (or well, 1 count actually). Anything with a count of 1 is then unused and we can warn the user about this.

Todo

Add hit count mechanism with touch(Variable)

Whenever a variable is referenced, whereever, add code to call touch(Variable)

Have a method which collects all 1-count variables and then returns them as an array of string[] for their identifiers

Compiler integration to print these out at some stage

Tests

Add a unittest for this, can be very basic

Documentation

Document the option typecheck:warnUnusedVars

Unit tests now added ✅

> ## What is this? > > We can add a component to the dependency generator which tracks the usage of variables. We can then call something like `touch(Varable)` whenever one is referenced. > > This can then increment an entry in a hashmap. > > For the quickest implementation for then comparing we should `touch(Variable)` on **declaration** as well and **not just** reference. Therefore we have them all in the hashmap and can find all `0` count ones, (or well, `1` count actually). Anything with a count of `1` is then unused and we can warn the user about this. > > ## Todo > > - [x] Add hit count mechanism with `touch(Variable)` > - [x] Whenever a variable is referenced, whereever, add code to call `touch(Variable)` > - [x] Have a method which collects all `1`-count variables and then returns them as an array of `string[]` for their identifiers > - [x] Compiler integration to print these out at some stage > > ### Tests > > - [ ] Add a unittest for this, can be very basic > > ### Documentation > > - [ ] Document the option `typecheck:warnUnusedVars` Unit tests now added ✅

deavmi stopped working 2023-11-05 14:38:13 +00:00

13 minutes 2 seconds

deavmi commented

2023-11-05 15:25:59 +00:00

What is this?

We can add a component to the dependency generator which tracks the usage of variables. We can then call something like touch(Varable) whenever one is referenced.

This can then increment an entry in a hashmap.

For the quickest implementation for then comparing we should touch(Variable) on declaration as well and not just reference. Therefore we have them all in the hashmap and can find all 0 count ones, (or well, 1 count actually). Anything with a count of 1 is then unused and we can warn the user about this.

Todo

Add hit count mechanism with touch(Variable)

Whenever a variable is referenced, whereever, add code to call touch(Variable)

Have a method which collects all 1-count variables and then returns them as an array of string[] for their identifiers

Compiler integration to print these out at some stage

Tests

Add a unittest for this, can be very basic

Documentation

Document the option typecheck:warnUnusedVars

Docs done

> ## What is this? > > We can add a component to the dependency generator which tracks the usage of variables. We can then call something like `touch(Varable)` whenever one is referenced. > > This can then increment an entry in a hashmap. > > For the quickest implementation for then comparing we should `touch(Variable)` on **declaration** as well and **not just** reference. Therefore we have them all in the hashmap and can find all `0` count ones, (or well, `1` count actually). Anything with a count of `1` is then unused and we can warn the user about this. > > ## Todo > > - [x] Add hit count mechanism with `touch(Variable)` > - [x] Whenever a variable is referenced, whereever, add code to call `touch(Variable)` > - [x] Have a method which collects all `1`-count variables and then returns them as an array of `string[]` for their identifiers > - [x] Compiler integration to print these out at some stage > > ### Tests > > - [x] Add a unittest for this, can be very basic > > ### Documentation > > - [ ] Document the option `typecheck:warnUnusedVars` Docs done

deavmi started working 2023-11-05 15:26:11 +00:00

deavmi commented

2023-11-05 15:26:25 +00:00

This is done, we should be able to merge soon.

deavmi stopped working 2023-11-05 15:32:27 +00:00

6 minutes 16 seconds

deavmi added a new dependency 2023-11-05 15:36:34 +00:00

#160 ⚡ Feature: Array reference counting

deavmi started working 2023-11-05 19:25:04 +00:00

deavmi commented

2023-11-05 19:31:30 +00:00

Added GitHub pipelines ✅
Fixed warning message typo ✅