Changes to generate anonymous types inside parent type's namespace

[desaikd]

Issue #103:

Description of changes:

This PR works on first portion of #103 issue which is defining a namespace corresponding to parent type for anonymous types. As described in the issue:

• For Java, this means that anonymous types(e.g. AnonymousType1) will be placed inside its parent class (e.g. Foo) in the same namespace (e.g. Foo.AnonymousType1)
• For Rust, this means that anonymous types(e.g. AnonymousType1) will be placed inside its parent type module(e.g. foo).

Generated code:

• Generated code for given ISL test files in Java can be found here
• Generated code for given ISL test files in Rust can be found here

List of changes:

• Changes to generate anonymous types as child classes in Java
  • Adds a new template anonymous_Type.templ which has macros to generate anonymous types as child classes
  • Modifies class.templ to include anonymous types as child classes
  • Modifies setter methods in class.templ to include base types in the arguments instead of AnonymousTypes
  • Modifies tests to remove reference to AnonymousTypes
  • Adds new util structure AnonymousType which will be used to render anonymous types as chilsren and modify setter methods to include base types
• Adds changes for generating anonymous types in child modules for Rust
  • Adds a new anonymous_type.templ template to generate a child module for anonymous types
  • Modifies struct.templ to use anonymous_type template

---

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

[desaikd]

Do the generated unit tests exercise this new functionality?

Yes, it does. The nested_struct.isl file contains a 2-level anonymous type/nested type for which the code generates, In Java the anonymous class into the parent class and for Rust the anonymous struct into parent struct's module.

[desaikd]

As per the conversation in this PR and offline, it would be simpler to express sequence and scalar nested types as is instead of creating another nested class/struct for it. This will be implemented in a separate PR. Example ISL:

type::{
   name: foo,
   fields: {
      sequence_type: { type: list, element: int },
      scalar_type: { type: string }
   }
}

Output Java:

class Foo {
   private sequence_type: ArrayList<Integer>; // current impl would treat it as `NestedTypeX`
   private scalar_type: String; // current impl would treat it as `NestedTypeY`
   ...
}