JSweetContext (JSweet transpiler 2.2.0-SNAPSHOT API)

java.lang.Object
- com.sun.tools.javac.util.Context
- - org.jsweet.transpiler.JSweetContext

```
public class JSweetContext
extends com.sun.tools.javac.util.Context
```
The transpiler context, which is an extension of the Java compiler context.

Author:

Renaud Pawlak

Nested Class Summary
- Nested classes/interfaces inherited from class com.sun.tools.javac.util.Context
  com.sun.tools.javac.util.Context.Factory<T>, com.sun.tools.javac.util.Context.Key<T>

Field Summary

Fields
Modifier and Type	Field and Description
`protected Set<String>`	`baseThrowables`
`boolean`	`bundleMode` A flag that indicates if we are building a bundle.
`Set<com.sun.tools.javac.code.Symbol.ClassSymbol>`	`classesWithWrongConstructorOverload` Contains the classes that have a wrong constructor overload.
`com.sun.tools.javac.tree.JCTree.JCCompilationUnit[]`	`compilationUnits` The compilation units that correspond to the source files.
`boolean`	`deprecatedApply` A flag that indicates if the transpiler should transform old-fashionned apply method to lambda or use the new convention ($apply)
`Map<Element,String>`	`docComments`
`List<File>`	`entryFiles` Source files containing a main method.
`Set<String>`	`globalImports` Globally imported name (in the global namespace).
`boolean`	`ignoreWildcardBounds` Tells JSweet to ignore wildcard bounds.
`Set<String>`	`importedTopPackages` Imported top packages (used to avoid clashes with local variables when bundle is on).
`protected Map<String,String>`	`langTypesMapping`
`protected Set<String>`	`langTypesSimpleNames`
`Set<com.sun.tools.javac.code.Symbol.VarSymbol>`	`lazyInitializedStatics` Holds all the static fields that are lazy intitialized.
`protected static org.apache.log4j.Logger`	`logger`
`Types`	`modelTypes`
`com.sun.tools.javac.util.Names`	`names` The Java compiler names for fast access.
`JSweetOptions`	`options` JSweet transpilation options.
`DirectedGraph<com.sun.tools.javac.code.Symbol.PackageSymbol>`	`packageDependencies` A graph containing the module dependencies when using modules (empty otherwise).
`boolean`	`reportedMultipleRootPackages` A flag to keep track of wether a multiple root packages problem was already reported (shall report only once).
`HashSet<com.sun.tools.javac.code.Symbol.PackageSymbol>`	`rootPackages` Store root packages (i.e.
`SourceFile[]`	`sourceFiles` The source files that are being transpiled.
`boolean`	`strictMode` A flag that indicates if the transpilation is in "strict" mode, which means that the `jsweet-core-strict` jar is in the classpath.
`com.sun.tools.javac.code.Symtab`	`symtab` The Java compiler symbol table for fast access.
`Set<String>`	`topLevelPackageNames` Stores the root package names (i.e.
`com.sun.tools.javac.code.Types`	`types` The Java compiler types for fast access.
`boolean`	`useModules` A flag to tell if the transpiler is in module mode or not.
`boolean`	`useRequireForModules` A flag to tell if the transpiler should transpiler modules to old fashioned require instructions rather than the ES2015 flavored syntax.

Constructor Summary

Constructors
Constructor and Description

JSweetContext(JSweetOptions options)
Creates a new JSweet transpilation context.

Constructors
Constructor and Description
`JSweetContext(JSweetOptions options)` Creates a new JSweet transpilation context.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAnnotation(Class<? extends Annotation> annotationType, String... filters)` Adds an annotation on the AST through global filters.
`void`	`addAnnotation(String annotationDescriptor, String... filters)` Adds an annotation on the AST through global filters.
`void`	`addAnnotationManager(AnnotationManager annotationManager)` Adds an annotation manager that will tune (add or remove) annotations on the AST.
`void`	`addAnnotationWithValue(Class<? extends Annotation> annotationType, Object value, String... filters)` Adds an annotation on the AST through global filters.
`void`	`addClassNameMapping(com.sun.tools.javac.code.Symbol.ClassSymbol clazz, String name)` Adds a name mapping to a class (rename it to avoid name clashes).
`void`	`addDefaultMethod(com.sun.tools.javac.tree.JCTree.JCCompilationUnit compilationUnit, com.sun.tools.javac.tree.JCTree.JCClassDecl type, com.sun.tools.javac.tree.JCTree.JCMethodDecl defaultMethod)` Stores a default method AST for the given type.
`void`	`addExportedElement(String moduleName, com.sun.tools.javac.code.Symbol exportedElement, com.sun.tools.javac.tree.JCTree.JCCompilationUnit compilationUnit)` Adds an exported element for a module.
`void`	`addFieldNameMapping(com.sun.tools.javac.code.Symbol.VarSymbol field, String name)` Adds a name mapping to a field (rename it to avoid name clashes).
`void`	`addFooterStatement(String footerStatement)` Adds a footer statement.
`void`	`addGlobalsMapping(String from, String to)` Adds a globals mapping.
`void`	`addHeader(String key, String header)` Sets a header (associated to a key).
`void`	`addJdkSubclass(String subclassName, TypeMirror extendedJdkClass)` Maps the name of a class to the JDK type it extends.
`void`	`addTopFooterStatement(String footerStatement)` Adds a footer statement at the first position.
`void`	`addTypeMapping(BiFunction<ExtendedElement,String,Object> mappingFunction)` Adds a functional type mapping.
`void`	`addTypeMapping(String sourceTypeName, String targetTypeName)` Adds a type mapping in the context.
`void`	`addTypeMappings(Map<String,String> nameMappings)` Adds a set of name-based type mappings.
`void`	`clearFooterStatements()` Clears the footer statements.
`void`	`clearHeaders()` Clear the headers.
`void`	`clearImportedNames(String moduleName)` Clears the names imported by the given module.
`void`	`countStaticInitializer(com.sun.tools.javac.code.Symbol.ClassSymbol clazz)` Increments the count of static initialization blocks for the given class.
`void`	`dumpOverloads(PrintStream out)` Dump all the overloads gathered by `OverloadScanner`.
`String`	`getActualName(com.sun.tools.javac.code.Symbol symbol)` Gets the actual name of a symbol from a JSweet convention, so including potential `jsweet.lang.Name` annotation.
`Set<OverloadScanner.Overload>`	`getAllOverloads()` Returns all the overloads in this context.
`<T> T`	`getAnnotationValue(com.sun.tools.javac.code.Symbol symbol, String annotationType, Class<T> propertyClass, T defaultValue)` Gets the first value of the 'value' property for the given annotation type if found on the given symbol.
`<T> T`	`getAnnotationValue(com.sun.tools.javac.code.Symbol symbol, String annotationType, String propertyName, Class<T> propertyClass, T defaultValue)` Gets the first value of the given property for the given annotation type if found on the given symbol.
`Set<String>`	`getBaseThrowables()`
`String`	`getClassNameMapping(com.sun.tools.javac.code.Symbol clazz)` Gets a class name mapping if any (null otherwise).
`com.sun.tools.javac.tree.JCTree.JCCompilationUnit`	`getDefaultMethodCompilationUnit(com.sun.tools.javac.tree.JCTree.JCMethodDecl defaultMethod)` Gets the compilation unit the given default method belongs to.
`Set<Map.Entry<com.sun.tools.javac.tree.JCTree.JCClassDecl,com.sun.tools.javac.tree.JCTree.JCMethodDecl>>`	`getDefaultMethods(com.sun.tools.javac.code.Symbol.TypeSymbol type)` Gets the default methods declared in the given type.
`String`	`getExportedElementName(com.sun.tools.javac.code.Symbol exportedElement)` Returns the idenfier of the given exported symbol, including Module annotation's name if specified
`Map<String,List<com.sun.tools.javac.code.Symbol>>`	`getExportedElements()` Gets the exported elements for all the modules defined in the program.
`String`	`getFieldNameMapping(com.sun.tools.javac.code.Symbol field)` Gets a field name mapping if any (null otherwise).
`com.sun.tools.javac.code.Symbol.PackageSymbol`	`getFirstEnclosingRootPackage(com.sun.tools.javac.code.Symbol.PackageSymbol packageSymbol)` Finds the first (including itself) enclosing package annotated with @Root.
`String`	`getFooterStatements()` Gets the footer statements.
`List<BiFunction<ExtendedElement,String,Object>>`	`getFunctionalTypeMappings()` Returns the functional type mappings.
`int`	`getFunctionalTypeParameterCount(com.sun.tools.javac.code.Type type)` Returns the number of arguments declared by a function interface.
`String`	`getGlobalsMappingString()` Returns the TypeScript string for globals mapping.
`String`	`getHeader(String key)` Returns a header for the given key (null if never set).
`String`	`getHeaders()` Gets the headers.
`Map<com.sun.tools.javac.code.Symbol,String>`	`getImportedElements(String moduleName)` The list of package names imported by the given m of the transpiled program.
`Set<String>`	`getImportedNames(String moduleName)` The list of names imported by the given module of the transpiled program.
`Map<String,TypeMirror>`	`getJdkSubclasses()` Maps the name of a class to the JDK type it extends.
`TypeMirror`	`getJdkSuperclass(String subclassName, Set<String> excludedJdkTypes)` Gets the JDK type extended by the given subclass, if any.
`Map<String,String>`	`getLangTypeMappings()`
`Set<String>`	`getLangTypesSimpleNames()`
`OverloadScanner.Overload`	`getOrCreateOverload(com.sun.tools.javac.code.Symbol.ClassSymbol clazz, com.sun.tools.javac.code.Symbol.MethodSymbol method)` Gets or create an overload instance for the given class and method.
`OverloadScanner.Overload`	`getOverload(com.sun.tools.javac.code.Symbol.ClassSymbol clazz, com.sun.tools.javac.code.Symbol.MethodSymbol method)` Gets an overload instance for the given class and method.
`String`	`getRootRelativeJavaName(com.sun.tools.javac.code.Symbol symbol)` Gets the qualified name of a symbol relatively to the root package (potentially annotated with `jsweet.lang.Root`).
`String`	`getRootRelativeName(Map<com.sun.tools.javac.code.Symbol,String> nameMapping, com.sun.tools.javac.code.Symbol symbol)` Gets the qualified name of a symbol relatively to the root package (potentially annotated with `jsweet.lang.Root`).
`String`	`getRootRelativeName(Map<com.sun.tools.javac.code.Symbol,String> nameMapping, com.sun.tools.javac.code.Symbol symbol, boolean useJavaNames)` Gets the qualified name of a symbol relatively to the root package (potentially annotated with `jsweet.lang.Root`).
`int`	`getStaticInitializerCount(com.sun.tools.javac.code.Symbol.ClassSymbol clazz)` Gets the static initializer count for the given class.
`com.sun.tools.javac.code.Symbol.PackageSymbol`	`getTopLevelPackage(com.sun.tools.javac.code.Symbol symbol)` Gets the top-level package enclosing the given symbol.
`String`	`getTypeMappingTarget(String sourceTypeName)` Returns the type the given type name is mapped through the `addTypeMapping(String, String)` or `addTypeMapping(String, String)` function.
`List<String>`	`getUsedModules()` The list of modules used by the transpiled program.
`String`	`getWildcardName(com.sun.tools.javac.tree.JCTree.JCWildcard wildcard)` Gets the wildcard name if any.
`List<com.sun.tools.javac.tree.JCTree.JCWildcard>`	`getWildcards(com.sun.tools.javac.code.Symbol holder)` Gets the registered wildcards for the given type parameter holder.
`void`	`grabMethodsToBeImplemented(List<com.sun.tools.javac.code.Symbol.MethodSymbol> methods, com.sun.tools.javac.code.Symbol.TypeSymbol type)`
`void`	`grabSuperClassNames(Set<String> superClasses, Element type)` Grabs the names of all the superclasses.
`void`	`grabSupportedInterfaceNames(Set<String> interfaces, com.sun.tools.javac.code.Symbol.TypeSymbol type)` Grabs the names of all the support interfaces in the class and interface hierarchy.
`boolean`	`hasAnnotationType(com.sun.tools.javac.code.Symbol symbol, String... annotationTypes)` Tells if the given symbol is annotated with one of the given annotation types.
`boolean`	`hasAnonymousFunction(com.sun.tools.javac.code.Symbol.TypeSymbol type)` Tells if the given type has a anonymous function (instances can be used as lambdas).
`boolean`	`hasClassNameMapping(com.sun.tools.javac.code.Symbol clazz)` Tells if the given class has a class name mapping.
`boolean`	`hasFieldNameMapping(com.sun.tools.javac.code.Symbol field)` Tells if the given field has a field name mapping.
`boolean`	`isAmbientDeclaration(com.sun.tools.javac.code.Symbol symbol)` Tells if the given symbol is ambient (part of a def.* package or within an `@Ambient`-annotated scope).
`boolean`	`isAnonymousClass(com.sun.tools.javac.tree.JCTree.JCNewClass newClass)` Returns true if this new class expression defines an anonymous class.
`boolean`	`isCoreFunctionalType(com.sun.tools.javac.code.Symbol.TypeSymbol type)` Returns true if the given type symbol corresponds to a core functional type.
`boolean`	`isFunctionalType(com.sun.tools.javac.code.Symbol.TypeSymbol type)` Returns true if the given type symbol corresponds to a functional type (in the TypeScript way).
`boolean`	`isIgnored(com.sun.tools.javac.tree.JCTree.JCClassDecl classdecl)` Returns true if this class declaration is not to be output by the transpiler.
`boolean`	`isInterface(com.sun.tools.javac.code.Symbol.TypeSymbol typeSymbol)` Tells if the given type is a Java interface.
`boolean`	`isInvalidOverload(com.sun.tools.javac.code.Symbol.MethodSymbol method)` Tells if that method is part of an invalid overload in its declaring class.
`boolean`	`isMappedType(String sourceTypeName)` Returns true if the given type name is mapped through the `addTypeMapping(String, String)` or `addTypeMapping(String, String)` function.
`boolean`	`isPackageErased(com.sun.tools.javac.code.Symbol.PackageSymbol pkg)` Returns true if the given package is erased (it could be erased because a parent package is erased).
`boolean`	`isRootPackage(Element element)` Returns true if the given symbol is a root package (annotated with @Root or a definition package).
`boolean`	`isUsingJavaRuntime()` Tells if the transpiler is using J4TS Java runtime.
`com.sun.tools.javac.tree.JCTree.JCClassDecl`	`lookupDecoratorAnnotation(String fullyQualifiedName)` Registers a decorator annotation in the context.
`com.sun.tools.javac.tree.JCTree[]`	`lookupGlobalMethod(String fullyQualifiedName)` Looks up a registered method from its fully qualified name.
`void`	`registerDecoratorAnnotation(com.sun.tools.javac.tree.JCTree.JCClassDecl annotationDeclaration)` Registers a decorator annotation in the context.
`void`	`registerGlobalMethod(com.sun.tools.javac.tree.JCTree.JCClassDecl owner, com.sun.tools.javac.tree.JCTree.JCMethodDecl method)` Registers a global method in the context.
`void`	`registerImportedName(String moduleName, com.sun.tools.javac.code.Symbol sourceElement, String targetName)` Register a name that is imported by the given package of the transpiled program.
`void`	`registerUsedModule(String moduleName)` Register a module that is used by the transpiled program.
`void`	`registerWildcard(com.sun.tools.javac.code.Symbol holder, com.sun.tools.javac.tree.JCTree.JCWildcard wildcard)` Registers a wilcard for a given container (type parameterized element).
`void`	`removeAnnotationManager(AnnotationManager annotationManager)` Removes the given annotation manager from the existing annotation manager chain.
`void`	`setUsingJavaRuntime(boolean usingJavaRuntime)` Sets the transpiler to use the J4TS Java runtime.

Methods inherited from class com.sun.tools.javac.util.Context
clear, dump, get, get, put, put, put, put

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - logger
```
protected static org.apache.log4j.Logger logger
```
  - langTypesMapping
```
protected Map<String,String> langTypesMapping
```
  - langTypesSimpleNames
```
protected Set<String> langTypesSimpleNames
```
  - baseThrowables
```
protected Set<String> baseThrowables
```
  - options
```
public final JSweetOptions options
```
    JSweet transpilation options.
  - classesWithWrongConstructorOverload
```
public Set<com.sun.tools.javac.code.Symbol.ClassSymbol> classesWithWrongConstructorOverload
```
    Contains the classes that have a wrong constructor overload.
  - symtab
```
public com.sun.tools.javac.code.Symtab symtab
```
    The Java compiler symbol table for fast access.
  - names
```
public com.sun.tools.javac.util.Names names
```
    The Java compiler names for fast access.
  - types
```
public com.sun.tools.javac.code.Types types
```
    The Java compiler types for fast access.
  - modelTypes
```
public Types modelTypes
```
  - useModules
```
public boolean useModules
```
    A flag to tell if the transpiler is in module mode or not.
  - useRequireForModules
```
public boolean useRequireForModules
```
    A flag to tell if the transpiler should transpiler modules to old fashioned require instructions rather than the ES2015 flavored syntax. import foo = require("foo"); instead of import * as foo from 'foo';
  - sourceFiles
```
public SourceFile[] sourceFiles
```
    The source files that are being transpiled.
  - compilationUnits
```
public com.sun.tools.javac.tree.JCTree.JCCompilationUnit[] compilationUnits
```
    The compilation units that correspond to the source files.
  - bundleMode
```
public boolean bundleMode
```
    A flag that indicates if we are building a bundle. In bundle mode, static fields will be initialized at the end of the bundle.
  - lazyInitializedStatics
```
public Set<com.sun.tools.javac.code.Symbol.VarSymbol> lazyInitializedStatics
```
    Holds all the static fields that are lazy intitialized.
  - entryFiles
```
public List<File> entryFiles
```
    Source files containing a main method.
  - packageDependencies
```
public DirectedGraph<com.sun.tools.javac.code.Symbol.PackageSymbol> packageDependencies
```
    A graph containing the module dependencies when using modules (empty otherwise).
  - topLevelPackageNames
```
public Set<String> topLevelPackageNames
```
    Stores the root package names (i.e. packages contained in the default package or in a package annotated with the jsweet.lang.Root annotation).
  - rootPackages
```
public HashSet<com.sun.tools.javac.code.Symbol.PackageSymbol> rootPackages
```
    Store root packages (i.e. packages contained in the default package or in a package annotated with the jsweet.lang.Root annotation, including null, i.e. default package).
  - reportedMultipleRootPackages
```
public boolean reportedMultipleRootPackages
```
    A flag to keep track of wether a multiple root packages problem was already reported (shall report only once).
  - globalImports
```
public Set<String> globalImports
```
    Globally imported name (in the global namespace).
  - importedTopPackages
```
public Set<String> importedTopPackages
```
    Imported top packages (used to avoid clashes with local variables when bundle is on).
  - strictMode
```
public boolean strictMode
```
    A flag that indicates if the transpilation is in "strict" mode, which means that the jsweet-core-strict jar is in the classpath.
  - deprecatedApply
```
public boolean deprecatedApply
```
    A flag that indicates if the transpiler should transform old-fashionned apply method to lambda or use the new convention ($apply)
  - ignoreWildcardBounds
```
public boolean ignoreWildcardBounds
```
    Tells JSweet to ignore wildcard bounds. For instance if ignored:
```
 void f(C c)
 
```
    will transpile to:
```
 f(c: C)
 
```
    otherwise:
```
 void f(C c)
 
```
    will transpile to:
```
 f<__T1 extends string>(c: C<__T1>)
 
```
  - docComments
```
public Map<Element,String> docComments
```
- Constructor Detail
  - JSweetContext
```
public JSweetContext(JSweetOptions options)
```
    Creates a new JSweet transpilation context.
    
    Parameters:
    
    options - the JSweet transpilation options
- Method Detail
  - addJdkSubclass
```
public void addJdkSubclass(String subclassName,
                           TypeMirror extendedJdkClass)
```
    Maps the name of a class to the JDK type it extends.
  - getJdkSubclasses
```
public Map<String,TypeMirror> getJdkSubclasses()
```
    Maps the name of a class to the JDK type it extends.
  - getJdkSuperclass
```
public TypeMirror getJdkSuperclass(String subclassName,
                                   Set<String> excludedJdkTypes)
```
    Gets the JDK type extended by the given subclass, if any.
  - registerGlobalMethod
```
public void registerGlobalMethod(com.sun.tools.javac.tree.JCTree.JCClassDecl owner,
                                 com.sun.tools.javac.tree.JCTree.JCMethodDecl method)
```
    Registers a global method in the context.
    
    See Also:
    
    lookupGlobalMethod(String)
  - lookupGlobalMethod
```
public com.sun.tools.javac.tree.JCTree[] lookupGlobalMethod(String fullyQualifiedName)
```
    Looks up a registered method from its fully qualified name.
    
    Parameters:
    
    fullyQualifiedName - fully qualified owning type name + "." + method name
    
    Returns:
    
    an array containing the class and method AST objects of any matching method (in theory several methods could match because of overloading but we ignore it here)
    
    See Also:
    
    #registerGlobalMethod(JCMethodDecl)
  - registerDecoratorAnnotation
```
public void registerDecoratorAnnotation(com.sun.tools.javac.tree.JCTree.JCClassDecl annotationDeclaration)
```
    Registers a decorator annotation in the context.
  - lookupDecoratorAnnotation
```
public com.sun.tools.javac.tree.JCTree.JCClassDecl lookupDecoratorAnnotation(String fullyQualifiedName)
```
    Registers a decorator annotation in the context.
  - addTypeMapping
```
public final void addTypeMapping(String sourceTypeName,
                                 String targetTypeName)
```
    Adds a type mapping in the context.
    
    Parameters:
    
    sourceTypeName - the fully qualified name of the source type
    
    targetTypeName - the fully Qualified name of the type the source type is mapped to
  - addTypeMappings
```
public final void addTypeMappings(Map<String,String> nameMappings)
```
    Adds a set of name-based type mappings. This method is equivalent to calling addTypeMapping(String, String) for each entry of the given map.
  - isMappedType
```
public final boolean isMappedType(String sourceTypeName)
```
    Returns true if the given type name is mapped through the addTypeMapping(String, String) or addTypeMapping(String, String) function.
  - getTypeMappingTarget
```
public final String getTypeMappingTarget(String sourceTypeName)
```
    Returns the type the given type name is mapped through the addTypeMapping(String, String) or addTypeMapping(String, String) function.
  - addTypeMapping
```
public final void addTypeMapping(BiFunction<ExtendedElement,String,Object> mappingFunction)
```
    Adds a functional type mapping.
    
    Parameters:
    
    mappingFunction - a function that takes the type tree, the type name, and returns a mapped type (either under the form of a string, or of a string, or of another type tree).
  - getFunctionalTypeMappings
```
public final List<BiFunction<ExtendedElement,String,Object>> getFunctionalTypeMappings()
```
    Returns the functional type mappings.
  - addAnnotationManager
```
public final void addAnnotationManager(AnnotationManager annotationManager)
```
    Adds an annotation manager that will tune (add or remove) annotations on the AST. Lastly added managers have precedence over firstly added ones.
  - removeAnnotationManager
```
public final void removeAnnotationManager(AnnotationManager annotationManager)
```
    Removes the given annotation manager from the existing annotation manager chain.
    
    See Also:
    
    addAnnotationManager(AnnotationManager)
  - addAnnotation
```
public final void addAnnotation(Class<? extends Annotation> annotationType,
                                String... filters)
```
    Adds an annotation on the AST through global filters.
    Example:
```
 context.addAnnotation(FunctionalInterface.class, "*.MyInterface");
 
```
    Filters are simplified regular expressions matching on the Java AST. Special characters are the following:
    - *: matches any token/identifier in the signature of the AST element
    - **: matches any list of tokens in signature of the AST element (same as ..)
    - ..: matches any list of tokens in signature of the AST element (same as **)
    - !: negates the filter (first character only)
    For example, to match:
    - all the elements in the x.y.z package: x.y.z.*
    - all the elements and subelements (fields, methods, ...) in the x.y.z package: x.y.z.**
    - all the methods in the x.y.z.A class: x.y.z.A.*(..)
    - all the methods taking 2 arguments in the x.y.z.A class: x.y.z.A.*(*,*)
    - all fields called aField in all the classes: **.aField
    Parameters:
    
    annotationType - the annotation type
    
    filters - the annotation is activated if one of the filters match and no negative filter matches
  - addAnnotationWithValue
```
public final void addAnnotationWithValue(Class<? extends Annotation> annotationType,
                                         Object value,
                                         String... filters)
```
    Adds an annotation on the AST through global filters. The annotation to be added is described by its type and by a value, which is passed as is to the annotation's value. If the annotation type does not accept a value parameter, no annotations will be added.
    
    See Also:
    
    addAnnotation(String, String...)
  - addAnnotation
```
public final void addAnnotation(String annotationDescriptor,
                                String... filters)
```
    Adds an annotation on the AST through global filters.
    Example:
```
 context.addAnnotation("@Erased", "*.writeObject(*)");
 context.addAnnotation("@Name('newName')", "*.MyDeclarationToBeRenamed");
 
```
    Filters are simplified regular expressions matching on the Java AST. Special characters are the following:
    - *: matches any character in the signature of the AST element
    - !: negates the filter (first character only)
    Parameters:
    
    annotationDescriptor - the annotation type name, optionally preceded with a @, and optionally defining a value (fully qualified name is not necessary for JSweet annotations)
    
    filters - the annotation is activated if one of the filters match and no negative filter matches
  - dumpOverloads
```
public void dumpOverloads(PrintStream out)
```
    Dump all the overloads gathered by OverloadScanner.
  - getAllOverloads
```
public Set<OverloadScanner.Overload> getAllOverloads()
```
    Returns all the overloads in this context.
  - getOrCreateOverload
```
public OverloadScanner.Overload getOrCreateOverload(com.sun.tools.javac.code.Symbol.ClassSymbol clazz,
                                                    com.sun.tools.javac.code.Symbol.MethodSymbol method)
```
    Gets or create an overload instance for the given class and method.
  - getOverload
```
public OverloadScanner.Overload getOverload(com.sun.tools.javac.code.Symbol.ClassSymbol clazz,
                                            com.sun.tools.javac.code.Symbol.MethodSymbol method)
```
    Gets an overload instance for the given class and method.
  - isInvalidOverload
```
public boolean isInvalidOverload(com.sun.tools.javac.code.Symbol.MethodSymbol method)
```
    Tells if that method is part of an invalid overload in its declaring class.
  - countStaticInitializer
```
public void countStaticInitializer(com.sun.tools.javac.code.Symbol.ClassSymbol clazz)
```
    Increments the count of static initialization blocks for the given class.
  - getStaticInitializerCount
```
public int getStaticInitializerCount(com.sun.tools.javac.code.Symbol.ClassSymbol clazz)
```
    Gets the static initializer count for the given class.
  - registerUsedModule
```
public void registerUsedModule(String moduleName)
```
    Register a module that is used by the transpiled program.
    
    Parameters:
    
    moduleName - the module being used
  - getUsedModules
```
public List<String> getUsedModules()
```
    The list of modules used by the transpiled program.
  - registerImportedName
```
public void registerImportedName(String moduleName,
                                 com.sun.tools.javac.code.Symbol sourceElement,
                                 String targetName)
```
    Register a name that is imported by the given package of the transpiled program.
```
 import targetName = require("sourceName");
 
```
    Parameters:
    
    moduleName - the module that is importing the name
    
    sourceElement - the source element if any (null if not applicable)
    
    targetName - the target name being imported
  - getImportedNames
```
public Set<String> getImportedNames(String moduleName)
```
    The list of names imported by the given module of the transpiled program.
  - getImportedElements
```
public Map<com.sun.tools.javac.code.Symbol,String> getImportedElements(String moduleName)
```
    The list of package names imported by the given m of the transpiled program.
  - clearImportedNames
```
public void clearImportedNames(String moduleName)
```
    Clears the names imported by the given module.
  - getExportedElements
```
public Map<String,List<com.sun.tools.javac.code.Symbol>> getExportedElements()
```
    Gets the exported elements for all the modules defined in the program.
  - getExportedElementName
```
public String getExportedElementName(com.sun.tools.javac.code.Symbol exportedElement)
```
    Returns the idenfier of the given exported symbol, including Module annotation's name if specified
  - addExportedElement
```
public void addExportedElement(String moduleName,
                               com.sun.tools.javac.code.Symbol exportedElement,
                               com.sun.tools.javac.tree.JCTree.JCCompilationUnit compilationUnit)
```
    Adds an exported element for a module.
  - clearFooterStatements
```
public void clearFooterStatements()
```
    Clears the footer statements.
  - getFooterStatements
```
public String getFooterStatements()
```
    Gets the footer statements.
  - addFooterStatement
```
public void addFooterStatement(String footerStatement)
```
    Adds a footer statement.
  - addTopFooterStatement
```
public void addTopFooterStatement(String footerStatement)
```
    Adds a footer statement at the first position.
  - clearHeaders
```
public void clearHeaders()
```
    Clear the headers.
  - getHeaders
```
public String getHeaders()
```
    Gets the headers.
  - addHeader
```
public void addHeader(String key,
                      String header)
```
    Sets a header (associated to a key).
    
    See Also:
    
    getHeader(String)
  - getHeader
```
public String getHeader(String key)
```
    Returns a header for the given key (null if never set).
    
    See Also:
    
    addHeader(String, String)
  - addGlobalsMapping
```
public void addGlobalsMapping(String from,
                              String to)
```
    Adds a globals mapping.
  - getGlobalsMappingString
```
public String getGlobalsMappingString()
```
    Returns the TypeScript string for globals mapping.
  - getDefaultMethods
```
public Set<Map.Entry<com.sun.tools.javac.tree.JCTree.JCClassDecl,com.sun.tools.javac.tree.JCTree.JCMethodDecl>> getDefaultMethods(com.sun.tools.javac.code.Symbol.TypeSymbol type)
```
    Gets the default methods declared in the given type.
  - addDefaultMethod
```
public void addDefaultMethod(com.sun.tools.javac.tree.JCTree.JCCompilationUnit compilationUnit,
                             com.sun.tools.javac.tree.JCTree.JCClassDecl type,
                             com.sun.tools.javac.tree.JCTree.JCMethodDecl defaultMethod)
```
    Stores a default method AST for the given type.
  - getDefaultMethodCompilationUnit
```
public com.sun.tools.javac.tree.JCTree.JCCompilationUnit getDefaultMethodCompilationUnit(com.sun.tools.javac.tree.JCTree.JCMethodDecl defaultMethod)
```
    Gets the compilation unit the given default method belongs to.
  - addFieldNameMapping
```
public void addFieldNameMapping(com.sun.tools.javac.code.Symbol.VarSymbol field,
                                String name)
```
    Adds a name mapping to a field (rename it to avoid name clashes).
  - getFieldNameMapping
```
public String getFieldNameMapping(com.sun.tools.javac.code.Symbol field)
```
    Gets a field name mapping if any (null otherwise).
  - hasFieldNameMapping
```
public boolean hasFieldNameMapping(com.sun.tools.javac.code.Symbol field)
```
    Tells if the given field has a field name mapping.
    
    See Also:
    
    #addFieldNameMapping(VarSymbol, String), getFieldNameMapping(Symbol)
  - addClassNameMapping
```
public void addClassNameMapping(com.sun.tools.javac.code.Symbol.ClassSymbol clazz,
                                String name)
```
    Adds a name mapping to a class (rename it to avoid name clashes).
  - getClassNameMapping
```
public String getClassNameMapping(com.sun.tools.javac.code.Symbol clazz)
```
    Gets a class name mapping if any (null otherwise).
  - hasClassNameMapping
```
public boolean hasClassNameMapping(com.sun.tools.javac.code.Symbol clazz)
```
    Tells if the given class has a class name mapping.
    
    See Also:
    
    #addClassNameMapping(ClassSymbol, String), getClassNameMapping(Symbol)
  - registerWildcard
```
public void registerWildcard(com.sun.tools.javac.code.Symbol holder,
                             com.sun.tools.javac.tree.JCTree.JCWildcard wildcard)
```
    Registers a wilcard for a given container (type parameterized element).
  - getWildcardName
```
public String getWildcardName(com.sun.tools.javac.tree.JCTree.JCWildcard wildcard)
```
    Gets the wildcard name if any.
  - getWildcards
```
public List<com.sun.tools.javac.tree.JCTree.JCWildcard> getWildcards(com.sun.tools.javac.code.Symbol holder)
```
    Gets the registered wildcards for the given type parameter holder.
  - isRootPackage
```
public boolean isRootPackage(Element element)
```
    Returns true if the given symbol is a root package (annotated with @Root or a definition package).
  - isInterface
```
public boolean isInterface(com.sun.tools.javac.code.Symbol.TypeSymbol typeSymbol)
```
    Tells if the given type is a Java interface.
  - hasAnnotationType
```
public boolean hasAnnotationType(com.sun.tools.javac.code.Symbol symbol,
                                 String... annotationTypes)
```
    Tells if the given symbol is annotated with one of the given annotation types.
  - getActualName
```
public String getActualName(com.sun.tools.javac.code.Symbol symbol)
```
    Gets the actual name of a symbol from a JSweet convention, so including potential jsweet.lang.Name annotation.
  - getTopLevelPackage
```
public com.sun.tools.javac.code.Symbol.PackageSymbol getTopLevelPackage(com.sun.tools.javac.code.Symbol symbol)
```
    Gets the top-level package enclosing the given symbol. The top-level package is the one that is enclosed within a root package (see jsweet.lang.Root) or the one in the default (unnamed) package.
  - getFirstEnclosingRootPackage
```
public com.sun.tools.javac.code.Symbol.PackageSymbol getFirstEnclosingRootPackage(com.sun.tools.javac.code.Symbol.PackageSymbol packageSymbol)
```
    Finds the first (including itself) enclosing package annotated with @Root.
  - getRootRelativeName
```
public String getRootRelativeName(Map<com.sun.tools.javac.code.Symbol,String> nameMapping,
                                  com.sun.tools.javac.code.Symbol symbol,
                                  boolean useJavaNames)
```
    Gets the qualified name of a symbol relatively to the root package (potentially annotated with jsweet.lang.Root).
    
    Parameters:
    
    nameMapping - a map to redirect names
    
    symbol - the symbol to get the name of
    
    useJavaNames - if true uses plain Java names, if false uses jsweet.lang.Name annotations
    
    Returns:
  - getRootRelativeName
```
public String getRootRelativeName(Map<com.sun.tools.javac.code.Symbol,String> nameMapping,
                                  com.sun.tools.javac.code.Symbol symbol)
```
    Gets the qualified name of a symbol relatively to the root package (potentially annotated with jsweet.lang.Root). This function takes into account potential jsweet.lang.Name annotations).
  - getRootRelativeJavaName
```
public String getRootRelativeJavaName(com.sun.tools.javac.code.Symbol symbol)
```
    Gets the qualified name of a symbol relatively to the root package (potentially annotated with jsweet.lang.Root). This function ignores jsweet.lang.Name annotations).
  - getAnnotationValue
```
public final <T> T getAnnotationValue(com.sun.tools.javac.code.Symbol symbol,
                                      String annotationType,
                                      Class<T> propertyClass,
                                      T defaultValue)
```
    Gets the first value of the 'value' property for the given annotation type if found on the given symbol.
  - getAnnotationValue
```
public <T> T getAnnotationValue(com.sun.tools.javac.code.Symbol symbol,
                                String annotationType,
                                String propertyName,
                                Class<T> propertyClass,
                                T defaultValue)
```
    Gets the first value of the given property for the given annotation type if found on the given symbol.
  - grabSupportedInterfaceNames
```
public void grabSupportedInterfaceNames(Set<String> interfaces,
                                        com.sun.tools.javac.code.Symbol.TypeSymbol type)
```
    Grabs the names of all the support interfaces in the class and interface hierarchy.
  - grabSuperClassNames
```
public void grabSuperClassNames(Set<String> superClasses,
                                Element type)
```
    Grabs the names of all the superclasses.
  - grabMethodsToBeImplemented
```
public void grabMethodsToBeImplemented(List<com.sun.tools.javac.code.Symbol.MethodSymbol> methods,
                                       com.sun.tools.javac.code.Symbol.TypeSymbol type)
```
  - isAnonymousClass
```
public boolean isAnonymousClass(com.sun.tools.javac.tree.JCTree.JCNewClass newClass)
```
    Returns true if this new class expression defines an anonymous class.
  - getFunctionalTypeParameterCount
```
public int getFunctionalTypeParameterCount(com.sun.tools.javac.code.Type type)
```
    Returns the number of arguments declared by a function interface.
  - isFunctionalType
```
public boolean isFunctionalType(com.sun.tools.javac.code.Symbol.TypeSymbol type)
```
    Returns true if the given type symbol corresponds to a functional type (in the TypeScript way).
  - isCoreFunctionalType
```
public boolean isCoreFunctionalType(com.sun.tools.javac.code.Symbol.TypeSymbol type)
```
    Returns true if the given type symbol corresponds to a core functional type.
  - hasAnonymousFunction
```
public boolean hasAnonymousFunction(com.sun.tools.javac.code.Symbol.TypeSymbol type)
```
    Tells if the given type has a anonymous function (instances can be used as lambdas).
  - isIgnored
```
public boolean isIgnored(com.sun.tools.javac.tree.JCTree.JCClassDecl classdecl)
```
    Returns true if this class declaration is not to be output by the transpiler.
  - isPackageErased
```
public boolean isPackageErased(com.sun.tools.javac.code.Symbol.PackageSymbol pkg)
```
    Returns true if the given package is erased (it could be erased because a parent package is erased).
  - isUsingJavaRuntime
```
public boolean isUsingJavaRuntime()
```
    Tells if the transpiler is using J4TS Java runtime. If yes, it will use the adapter that tries to delegate to the Java emulation layer for the Java API.
  - setUsingJavaRuntime
```
public void setUsingJavaRuntime(boolean usingJavaRuntime)
```
    Sets the transpiler to use the J4TS Java runtime.
  - getLangTypeMappings
```
public final Map<String,String> getLangTypeMappings()
```
  - getLangTypesSimpleNames
```
public final Set<String> getLangTypesSimpleNames()
```
  - getBaseThrowables
```
public final Set<String> getBaseThrowables()
```
  - isAmbientDeclaration
```
public boolean isAmbientDeclaration(com.sun.tools.javac.code.Symbol symbol)
```
    Tells if the given symbol is ambient (part of a def.* package or within an @Ambient-annotated scope).

Class JSweetContext

Nested Class Summary

Nested classes/interfaces inherited from class com.sun.tools.javac.util.Context

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.sun.tools.javac.util.Context

Methods inherited from class java.lang.Object

Field Detail

logger

langTypesMapping

langTypesSimpleNames

baseThrowables

options

classesWithWrongConstructorOverload

symtab

names

types

modelTypes

useModules

useRequireForModules

sourceFiles

compilationUnits

bundleMode

lazyInitializedStatics

entryFiles

packageDependencies

topLevelPackageNames

rootPackages

reportedMultipleRootPackages

globalImports

importedTopPackages

strictMode

deprecatedApply

ignoreWildcardBounds

docComments

Constructor Detail

JSweetContext

Method Detail

addJdkSubclass

getJdkSubclasses

getJdkSuperclass

registerGlobalMethod

lookupGlobalMethod

registerDecoratorAnnotation

lookupDecoratorAnnotation

addTypeMapping

addTypeMappings

isMappedType

getTypeMappingTarget

addTypeMapping

getFunctionalTypeMappings

addAnnotationManager

removeAnnotationManager

addAnnotation

addAnnotationWithValue

addAnnotation

dumpOverloads

getAllOverloads

getOrCreateOverload

getOverload

isInvalidOverload

countStaticInitializer

getStaticInitializerCount

registerUsedModule

getUsedModules

registerImportedName

getImportedNames

getImportedElements

clearImportedNames

getExportedElements

getExportedElementName

addExportedElement

clearFooterStatements

getFooterStatements

addFooterStatement

addTopFooterStatement

clearHeaders

getHeaders

addHeader