New FrontEnd

[Per Östlund]

This ticket is tracking the progress on the the new frontend. Some documentation on the new frontend development is available on wiki:NewFrontEnd.

The current status is:

Instantiation (Per, Adrian) 80%

Instantiation of long and short class definitions are implemented. Still missing are overloaded functions and partial derivative functions. Basic support for class extends is implemented. The handling of equations, algorithms and expressions needs to be expanded.

Extends (Per) 90%

Support for extends is implemented. More error checking is needed though, e.g. for duplicate elements (handling implemented, but the check whether two elements are identical needs to be improved) and illegal class types.

Lookup (Per) 90%

Basic lookup is implemented, both for class names and crefs. Very little error checking is done beyond "name could not be found" though. Some more lookup functions will likely be needed for e.g. inner/outer.

Modifiers (Per) 80%

Support of modifiers on components, extends clauses and class modifiers is implemented, more testing is needed.

Redeclare (Per) 60%

Basic redeclare of components and classes, both as modifiers and elements, is implemented. Merging of modifiers, constraining type, etc., needs more work.

Imports (Per, Adrian) 90%

Imports are now mostly handled, both for classes and components. More error checking is needed:

• Enforce that imports use the form [package.]definition.
• Handle shadowing correctly.

Conditional Components (Lennart)

No support for conditional components implemented. This needs support from constant/function evaluation and expression simplification. It can be implemented after typing together with handling of component bindings.

Inner/Outer (Adrian)

No support for Inner/Outer is implemented at all so far, but the new instance tree structure should make this fairly straightforward. The inner outer can be implemented via addition of alias equations, is a matter of lookup of the inner component and prefixing.

Functions (Per, Adrian, Peter, Mahder) 75%

Partial support for functions. Instantiation and typing of functions is implemented. Positional arguments and named arguments are supported. *Vectorization support needs do be adapted*. Preliminary support for reductions is implemented. Support for function trees exists.

Records (Mahder) 85%

Support for records and for record constructors in the works.

Builtin (Per, Mahder) 50%

So far only support for the basic types and time is implemented. Support for all the builtin functions and other builtin things (e.g. StateSelect, ExternalObject, etc.) needs to be implemented. As much as possible should be implemented via ModelicaBuiltin. Tests added. Support for functions with variable number of arguments not yet implemented.

Reduction operators and Builtin Array functions (Mahder) 80%

First the function handling needs to be completed by Mahder. Adapt the old Static.mo to the new expressions types in the NF. matrix, vector, scalar, {}, [].

Typing (Mahder, Peter) 70%

Quite a lot of typing is already implemented, but it needs to be expanded to handle all kinds of expressions and so on.

Type Checking (Mahder, Peter, Per) 65%

Some parts of the type checking module from the "old new frontend" is being used to type check binary expressions at the moment. Everything in NFTypeCheck that's not used is commented out since some of it doesn't compile any more. We need to investigate if more of the old code can be reused, and implement missing/nonreusable parts.

Flattening (Per) 40%

Expansion of array bindings is currently broken and need to be fixed. Subscripting needs to be improved, and the module in general needs to be expanded to keep up with the phases before it.

Connection Handling (Adrian) 60%

Handling of connect equations using the DAE and the instance tree.

Unit checking (Arun) 100%

Ported the backend unit checking to the new frontend. Added tests. Based on the DAE intermediate form.

Operator Overloading (Mahder & Martin) 70%

The support for operator overloading from the current front-end (or the previous implementation of the new front-end) should be ported to the new front-end. Most of the Operator Overloading resolution is done, lookup of actual deoverloaded functions is needed.

Constant Evaluation (Lennart) 90%

Constant evaluate structural parameters (minimal) or any other constant/parameter bindings (not by default). Per implemented a new type of DAE component reference that contains links to the instantiated component tree on which one can do evaluation of bindings. Support for evaluating expressions has been implemented except ranges, sizes, records. We should ONLY evaluate what we need and nothing more.

Function Evaluation (Lennart) 1%

Sometimes to evaluate structural parameters one needs to evaluate functions. This will port the function interpretation from the current front-end to the new front-end.

Expression Simplification (Lennart) 20%

Expression simplification is needed together with constant/function evaluation to evaluate structural parameters. This needs to be a separate package so that can be reused in some other parts of the compiler. Support for expression simplification has been implemented except for functions, array slices.

Local balance checking (Mahder)

This will check the balance checking for each model so that errors can be detected sooner. We had no such support in the current front-end.

Synchronous Features (BernhardT)

The handling of the synchronous features (Clocks, etc) and state machines should be ported from the current front-end to the new front-end. This functionality needs function, builtin and inner/outer support.

OMC <-> OMEdit Communication (Adeel, Adrian) 70%

The new front-end should be used by OMEdit to query information about a model instantiation. A new OMC API is needed to handle the GUI in a much faster way than with the current front-end. OMEdit should query the instantiated class directly to retrieve components, annotations, etc.

[Francesco Casella]

Still some problems with component modifiers. Running the following test script

loadString("
package P
  model A
    parameter Real p;
  end A;
  model B
    parameter Real q = 2;
    A a1(p = q);
  end B;
  model C
    parameter Real q = 2;
    A a1(p = q);
    A a2(p = q);
  end C;
end P;
");
setCommandLineOptions("-d=newInst");
instantiateModel(P.B);
instantiateModel(P.C);

returns

true
true
"class B
  parameter Real q = 2;
  parameter Real a1.p = q;
end B;
"
""

so for some reason model C is not instantiated at all.

[Per Östlund]

Replying to casella:

Still some problems with component modifiers.

I am well aware of that, and have already fixed this particular issue locally a while ago. At the moment I'm not really interested in bug reports though, the new instantiation is not ready for public testing yet.

[Francesco Casella]

Replying to perost:

At the moment I'm not really interested in bug reports though, the new instantiation is not ready for public testing yet.

Q1: Can you give a reasonable estimate of when this will be possible?

Q2: Is the interface towards the other tasks of Phase 2 already stabilized? If not, when will it reasonably be?

[Per Östlund]

Replying to casella:

Q1: Can you give a reasonable estimate of when this will be possible?

No

Q2: Is the interface towards the other tasks of Phase 2 already stabilized? If not, when will it reasonably be?

Maybe

[Per Östlund]

Class modifiers have been implemented now, but needs more testing.

[Francesco Casella]

The test case reported in comment:4 now produces the expected result

[Francesco Casella]

However, instantiating P.S in the attached test case still fails

[Per Östlund]

Replying to casella:

However, instantiating P.S in the attached test case still fails

It works fine for me, are you using the latest nightly build?

[Francesco Casella]

Replying to perost:

Replying to casella:

However, instantiating P.S in the attached test case still fails

It works fine for me, are you using the latest nightly build?

I thought so, but I wasn't. With OpenModelica-v1.11.0-dev-288-g2ccad20-64bit, it works fine for me also :)

[Per Östlund]

Initial support for enumerations is now implemented.

[Francesco Casella]

Added link to wiki page

[Adrian Pop]

Small status update.

[Francesco Casella]

I just tried out ScalableTestSuite.Elementary.SimpleODE.Models.CascadedFirstOrder:

model CascadedFirstOrder
  parameter Integer N = 10 "Order of the system";
  parameter Modelica.SIunits.Time T = 1 "System delay";
  final parameter Modelica.SIunits.Time tau = T/N "Individual time constant";
  Real x[N] (each start = 0, each fixed = true);
equation
  tau*der(x[1]) = 1 - x[1];
  for i in 2:N loop
    tau*der(x[i]) = x[i-1] - x[i];
  end for;
end CascadedFirstOrder;

but it still doesn't work, I get

Error: Type mismatch for positional argument 1 in der(x=x[1]).
The argument has type: Real[10]
expected type: Real

This is a very basic model, and it doesn't use arrays in any fancy way. This error looks to me more like a bug than a missing feature.

Would you mind fixing this issue so we can start getting some results from testing the ScalableTestSuite with the new front-end?

Thanks

Francesco

[Per Östlund]

Replying to casella:

This is a very basic model, and it doesn't use arrays in any fancy way. This error looks to me more like a bug than a missing feature.

Subscripting is not implemented yet, so it is actually a missing feature. It's high up on my todo list, but other things currently has higher priority for me.

[Francesco Casella]

OK. I interpreted "Subscripting needs to be improved" as "there is already some subscripting implemented" :)

[Per Östlund]

Updated description for redeclares (better in general, but class extends/element redeclares currently broken) and imports.

[Per Östlund]

Replying to casella:

Would you mind fixing this issue so we can start getting some results from testing the ScalableTestSuite with the new front-end?

This model should start working in about five minutes, once Hudson pulls in my latest changes.

[Francesco Casella]

Very good!