Big update to prettier-extension-monkeyc

Sounds reasonable to only propagate typecheck if parent hasn't got one yet. Maybe there could also be a warning when you can't propagate (especially that it's possible that parent doesn't have it in the original code, but it got one because of a previous inclined function) with the exception when not propagating it shouldn't matter (not sure if this is something you can know though, but the obvious example is if the same typecheck annotation is the one already present on the parent)

So thinking about this, there's a simple solution.

If either function has a typecheck(false), I should add typecheck(false) to the caller, and drop any other typecheck annotation. Otherwise, make a list of all the distinct names that appear (currently I think the only valid ones are disableBackgroundCheck and disableGlanceCheck - but I can just gather whatever is there), and combine them into a single typecheck([...names]). If there's only one name, I can drop the square brackets.

I think that should handle everything...

There's a new bug in 2.0.48:

import Toybox.Application;
import Toybox.Lang;
import Toybox.Math;

(:api2, :inline)
function getImpl(key as PropertyKeyType) as PropertyValueType or Null {
    return Properties.getValue(key);
}
function getConf(key as PropertyKeyType) as PropertyValueType or Null {
    var val;
    try {
        val = getImpl(key);
    } catch (e) {
        val = null;
    }
    return val;
}


(:inline)
function getNumber(key as PropertyKeyType, defaultValue as Number) as Number {
    return toNum(getConf(key), defaultValue);
}
function toNum(value as PropertyValueType?, defaultValue as Number) as Number { // code: 10396 data: 4219
    if (value instanceof Lang.Boolean) {
        return value ? 1 : 0;
    }
    value = value != null && value has :toNumber ? value.toNumber() : null;
    return value != null ? value as Number : defaultValue;
}

public function uninitializedBug() as Void {
    var zero = 0;
    var u = "u";    var antId = Math.rand();
    var emptyIndex = null;
    for (var idx = 1; idx <= 2; idx++) {
        var extAntId = getNumber("X" + idx, zero);
        if (antId == extAntId) {
            emptyIndex = idx;
            break;
        } else if (emptyIndex == null && extAntId == zero) {
            emptyIndex = idx;
        }
    }
}

In the generated code of the last function you have:

    var extAntId;
    if (antId == toNum(getConf("X" + idx), 0)) {
      break;
    } else if (emptyIndex == null && extAntId == 0) {
      emptyIndex = idx;
    }

so I get:

bin/optimized/group005-debug/source/source/Test.mc:30,11: Value may not be initialized.

flocsy said:

There's a new bug in 2.0.48

I can repro. Turning off "Single Use Copy Prop" fixes it.

It's a formatter bug. Your example, with a closing brace added, crashes the formatter...

(:background_app, /*:api1_3,*/ :stats) // comment
// class Stats { // comment
module Stats { //
}

flocsy said:

There's a new bug in 2.0.48:

v2.0.49 fixes that, and the formatter crash.

It also extends single use copy prop to work with update assignments, so that

var x = a + b; x += c; becomes var x; x = (a + b) + c; and

...; x += c; return x; becomes ...; return x + c;

Ok, 2.0.49 works.

There was (for a some time) a warning that some of my code will only compile with the newer compiler or -O1+. For example:

flocsy said:

I don't know if this was known to you

Yes, I've been aware of it for a long time, but I've not implemented the optimization. For one thing, there aren't many opportunities... I think it's only Properties, Storage, and Gregorian.

I suppose if someone wrote Toybox.Application without doing the import I could optimize that - but I don't really see any examples of that (except in some of my tests!). In fact I think people generally assume (as I did for a long time) that you *have* to import Toybox.Application if you want to use Application - when in fact it just saves using the full path.

import Toybox.Lang;
import Toybox.System;

(:foo)
function notHere() {
    System.println("notHere");
}

(:foo)
function cond() as Boolean {
    return true;
}
(:bar)
function cond() as Boolean {
    return false;
}

(:bar)
function b() {
    if (cond()) {
        notHere();
    }
}

When you compile this with excludeAnnotation foo then there's a warning:

ERROR> fenix6: Test.mc:21:9: 'notHere' is not callable

Which is kind of true, but the optimizer later is more clever and removes the if (cond()) block, because it understands that cond() will always be false, so basically the warning was not needed.

This is not a huge deal, just that you know about it.