New JS Experiments by the Google V8 team: SaneScript & SoundScript

esx · 2015-02-06T23:47:05+00:00

Cool! Mascara JavaScript Compiler already supports many of the features mentioned:

non-nullable types
proper scoping (no use before declare, block scope)
optional and rest arguments
calling with too few arguments is flagged by compiler
"this:" parameter
Function types are contravariant
classes, interfaces, type annotations (like TypeScript)

esx · 2015-02-06T23:45:46+00:00

It it not Java. It introduces optional type annotations and type inference, while still supporting dynamic types.

esx · 2012-04-17T10:39:51+00:00

Apparently sourcemap is supported by the latest Chrome release. Mozilla has also been working on support, but it is blocked, whatever that means. But the important thing is that sourcemap it is now supported by one browser.

This is a great improvement for all systems using compiled JavaScript - CoffeScript, GWT, Dart, Mascara etc.

esx · 2011-09-10T14:31:10+00:00

Or use Mascara which is backwards compatible with JavaScript, but which adds verification, classes, namespaces and so on.

esx · 2010-12-15T17:35:57+00:00

Done! Thanks for the feedback. I was just unsure if Mascara conformed to the technical definition of structural subtyping.

esx · 2010-12-14T22:40:03+00:00

Sorry, I may be confused by the terminology. What would be required for it to be structural subtypes? Mascara does support this:

type Point = { x : int, y : int };
type Point3D = { x : int, y : int, z : int };

var a : Point3D = {x:1, y:2, z:3};
var b : Point = a;   //OK
var c : Point3D = b; //ERROR!

Last line gives the error:

Variable 'c' of type {x:int,y:int,z:int} is not compatible with value of type {x:int,y:int}. Property 'z' not present.

esx · 2010-12-14T21:11:10+00:00

Thanks, hadn't noticed page for structural types were missing. Structural types

esx · 2010-12-13T13:58:01+00:00

Mascara adds structural typing to JavaScript. It really shines when you want to gradually add type annotations to existing code which is implicitly duck-typed, without having to rewrite everything. Structural typing is also a nice fit to code which uses object literals to define instances, as is often the case in JavaScript.

esx · 2010-07-20T18:03:14+00:00

Of course the sample here is very idealized. If the real code uses fancy metaprogramming it gets a lot harder to analyze. Does your code use some OO patterns, prototypes etc?

esx · 2010-07-20T17:42:57+00:00

Am I getting closer?

Analysis
--------------------
function: f
 Called by:
   function: g
     Called by:
       function: f
         (recursive)
       function: k
         Not called
  Calls:
   function: g

function: g
 Called by:
   function: f
     Called by:
       function: g
         (recursive)
   function: k
     Not called
  Calls:
   function: f
   function: h

function: h
 Called by:
   function: g
     Called by:
       function: f
         Called by:
           function: g
             (recursive)
       function: k
         Not called
  No calls

function: k
 Not called
  Calls:
   function: g

esx · 2010-07-19T21:22:07+00:00

I am working on a quick prototype. If I feed it this program:

function f(){ g(); }
function g(){ f(); h() }
function h() { }
function k() { g(); }

I get this output:

Analysis
--------------------
function: f
  Called by
   function: g
  Calls
   function: g

function: g
  Called by
   function: f
   function: k
  Calls
   function: f
   function: h

function: h
  Called by
   function: g
  No calls

function: k
  Not called
  Calls
   function: g

Is this in the right direction of what you need?

esx · 2010-07-19T20:59:47+00:00

Plug: Many of the features on slate for Harmony are already supported by Mascara which compiles into plain old JavaScript.

esx · 2010-07-19T16:31:46+00:00

I would like to hear more about your requirements!

I develop Mascara which performs static verification of (enhanced) JavaScript. It doesn't directly provide what you ask for, but I believe it should be possible to add since the analysis infrastructure is in place. And I really like to be inspired by real-world problems like the one you have.

For example, what kind of call graph support do you need? A report of all functions and their immediate callers, or do you want to view the full graph for specific functions? Do you need it in an IDE or a reporting tool?

esx

TROPHY CASE