private static void __Execute(atom.Trace context, int level, ImportDeclaration data, string file)
{
context.
SetComment("import", "[[[Data Type]]]").
SetUrl(file, __GetLine(data, data.Pos.Value), __GetPosition(data, data.Pos.Value)).
Send(NAME.SOURCE.PREVIEW, NAME.TYPE.PARAMETER, level, data.GetText());
}
private Ust VisitImportDeclaration(ImportDeclaration importDeclaration)
{
var name = (UstLiterals.StringLiteral)VisitLiteral(importDeclaration.Source);
Logger.LogDebug($"{nameof(ImportDeclaration)}.{nameof(ImportDeclaration.Specifiers)} are not supported for now");
return(new UsingDeclaration(name, GetTextSpan(importDeclaration)));
}
public CSharpSyntaxNode Convert(ImportSpecifier specifier)
{
ImportDeclaration import = specifier.Ancestor(NodeKind.ImportDeclaration) as ImportDeclaration;
Document fromDoc = import?.FromDocument;
Node definition = fromDoc?.GetExportTypeDefinition(specifier.DefinitionName);
if (definition != null)
{
string definitionPackage = definition.Document.GetPackageName();
string package = import.Document.GetPackageName();
string name = specifier.Name.Text;
string propertyName = (string)definition.GetValue("NameText");
List <Node> genericParameters = definition.GetValue("TypeParameters") as List <Node>;
if (genericParameters != null && genericParameters.Count > 0 && package != definitionPackage) // generic use using.
{
return(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(definitionPackage)));
}
else if (package != definitionPackage || name != propertyName)
{
return(SyntaxFactory.UsingDirective(
SyntaxFactory.NameEquals(name),
SyntaxFactory.ParseName($"{definitionPackage}.{propertyName}")));
}
}
return(null);
}
protected override void VisitImportDeclaration(ImportDeclaration importDeclaration)
{
using (StartNodeObject(importDeclaration))
{
Member("specifiers", importDeclaration.Specifiers, e => (INode)e);
Member("source", importDeclaration.Source);
}
}
public static ImportDeclaration CreateImportDeclaration(string dataAreaId, string importDeclarationNumber, global::System.DateTimeOffset nationalizationDate, global::System.DateTimeOffset importDeclarationDate, decimal aFRMM)
{
ImportDeclaration importDeclaration = new ImportDeclaration();
importDeclaration.dataAreaId = dataAreaId;
importDeclaration.ImportDeclarationNumber = importDeclarationNumber;
importDeclaration.NationalizationDate = nationalizationDate;
importDeclaration.ImportDeclarationDate = importDeclarationDate;
importDeclaration.AFRMM = aFRMM;
return(importDeclaration);
}
public TypescriptImport(ImportDeclaration node, string rootDir) : base(node, rootDir)
{
_path = node.Children.OfType <StringLiteral>().First();
var namedImports = node.GetDescendants(false).OfType <ImportSpecifier>().Select(i => new ImportedModule(i, _path, AbsolutePath)).ToArray();
var namespaceImports = node.GetDescendants(false).OfType <NamespaceImport>()
.Select(i => new ImportedModule(i, _path, AbsolutePath)).ToArray();
var allImports = new List <ImportedModule>();
allImports.AddRange(namedImports);
allImports.AddRange(namespaceImports);
ImportedModules = allImports;
}
public CSharpSyntaxNode Convert(NamespaceImport node)
{
ImportDeclaration import = node.Ancestor(NodeKind.ImportDeclaration) as ImportDeclaration;
Document fromDoc = node.Project.GetDocumentByPath(import.ModulePath);
if (fromDoc != null)
{
return(SyntaxFactory.UsingDirective(
SyntaxFactory.NameEquals(node.Name.Text),
SyntaxFactory.ParseName(fromDoc.GetPackageName())));
}
return(null);
}
public SyntaxList <UsingDirectiveSyntax> Convert(ImportClause node)
{
SyntaxList <UsingDirectiveSyntax> usings = new SyntaxList <UsingDirectiveSyntax>();
if (node.Name != null) // default
{
ImportDeclaration import = node.Ancestor(NodeKind.ImportDeclaration) as ImportDeclaration;
Syntax.Document fromDoc = import?.FromDocument;
Node definition = fromDoc?.GetExportDefaultTypeDefinition();
if (definition != null)
{
string definitionPackage = definition.Document.GetPackageName();
string package = import.Document.GetPackageName();
string name = node.Name.Text;
string propertyName = (string)definition.GetValue("NameText");
if (package != definitionPackage || name != propertyName)
{
UsingDirectiveSyntax usingSyntax = SyntaxFactory.UsingDirective(
SyntaxFactory.NameEquals(name),
SyntaxFactory.ParseName($"{definitionPackage}.{propertyName}"));
usings = usings.Add(usingSyntax);
}
}
}
if (node.NamedBindings != null)
{
switch (node.NamedBindings.Kind)
{
case NodeKind.NamespaceImport:
UsingDirectiveSyntax usingSyntax = node.NamedBindings.ToCsNode <UsingDirectiveSyntax>();
if (usingSyntax != null)
{
usings = usings.Add(usingSyntax);
}
break;
case NodeKind.NamedImports:
usings = usings.AddRange(node.NamedBindings.ToCsNode <IEnumerable <UsingDirectiveSyntax> >());
break;
default:
break;
}
}
return(usings);
}
public Imports(string sourceFileName, string root, ImportDeclaration importDeclaration)
{
_sourceFileName = sourceFileName;
_root = root;
ImportDeclaration = importDeclaration;
_pathNode = importDeclaration.Children.OfType <StringLiteral>().First();
_path = _pathNode.Text;
var namedImports = importDeclaration.GetDescendants(false).OfType <ImportSpecifier>().Select(i => new ImportedModule(i, _pathNode)).ToArray();
var namespaceImports = importDeclaration.GetDescendants(false).OfType <NamespaceImport>()
.Select(i => new ImportedModule(i, _pathNode)).ToArray();
var allImports = new List <ImportedModule>();
allImports.AddRange(namedImports);
allImports.AddRange(namespaceImports);
ImportedModules = allImports;
}
public override Base VisitImport_spec([NotNull] GolangParser.Import_specContext context)
{
ImportDeclaration ret = null;
var first = context.GetChild(0).Accept(this) as RawNode;
if (context.ChildCount == 2)
{
var second = context.GetChild(1).Accept(this) as RawNode;
ret = new ImportDeclaration(second.Text.Trim('"'), first.Text);
}
else
{
ret = new ImportDeclaration(first.Text.Trim('"'), string.Empty);
}
m_currentPackage.AddImport(ret);
return(ret);
}
private void ExtractImports(ModuleData module, ImportDeclaration importDeclaration, ModuleFile moduleFile)
{
for (int i = 0, n = importDeclaration.Specifiers.Count; i < n; i++)
{
switch (importDeclaration.Specifiers[i])
{
// import localName from 'src/my_lib';
case ImportDefaultSpecifier importDefaultSpecifier:
module.Imports[importDefaultSpecifier.Local.Name] = new NamedImportData(moduleFile, importDefaultSpecifier.Local.Name, DefaultExportName);
break;
// import * as my_lib from 'src/my_lib';
case ImportNamespaceSpecifier importNamespaceSpecifier:
module.Imports[importNamespaceSpecifier.Local.Name] = new NamespaceImportData(moduleFile, importNamespaceSpecifier.Local.Name);
break;
// import { name1 } from 'src/my_lib';
// import { default as foo } from 'src/my_lib';
case ImportSpecifier importSpecifier:
module.Imports[importSpecifier.Local.Name] = new NamedImportData(moduleFile, importSpecifier.Local.Name, importSpecifier.Imported.Name);
break;
}
}
}
protected virtual void VisitImportDeclaration(ImportDeclaration importDeclaration)
{
}
public virtual void EnterImportDeclaration(ImportDeclaration importDeclaration)
{
}
public void TestImportDeclaration()
{
ImportDeclaration node = new ImportDeclaration(GetImportOrExportClause(), GetExpression1(), GetExpression2(), GetExpressionList(), Declaration.DeclarationFlags.Export, DefaultLineInfo);
CheckSerializationRoundTrip(node);
}
public static TypescriptImport Create(ImportDeclaration node, string rootDir)
{
return(new TypescriptImport(node, rootDir));
}
public CompilationUnit(PackageDeclaration packageDeclaration, ImportDeclaration importDeclaration, List <TypeDeclaration> typeDeclarations)
{
this.packageDeclaration = packageDeclaration;
this.importDeclaration = importDeclaration;
this.typeDeclarations = typeDeclarations;
}
/**
* Call back method that must be called when the given <code>
* ImportDeclaration</code> will become the next <i>traverse candidate</i>.
*
* @param pImportDeclaration The <code>ImportDeclaration</code> object that
* will become the next <i>traverse
* candidate</i>.
*/
public void performAction(
ImportDeclaration pImportDeclaration)
{
// Nothing to do.
}
public TypescriptInterface(ImportDeclaration node, string rootDir) : base(node, rootDir)
{
}
void ImportDecl(out ImportDeclaration decl)
{
decl = null; var has_in = false; PathExpression path;
Identifier alias = null; var entities = new List<PathExpression>();
while (!(la.kind == 0 || la.kind == 31)) {SynErr(109); Get();}
Expect(31);
PathExpression(out path);
entities.Add(path);
if (la.kind == 32) {
Get();
Expect(14);
if(!CheckKeyword(t.val)){
alias = AstNode.MakeIdentifier(t.val, CurrentLocation);
Symbols.AddSymbol(t.val, alias);
}else{
// Failed to parse an alias name.
// Leave the parser to recover its state.
}
} else if (la.kind == 12 || la.kind == 24) {
while (WeakSeparator(12,3,4) ) {
PathExpression(out path);
entities.Add(path);
}
Expect(24);
has_in = true;
PathExpression(out path);
} else SynErr(110);
while (!(la.kind == 0 || la.kind == 6)) {SynErr(111); Get();}
Expect(6);
if(has_in)
decl = AstNode.MakeImportDecl(path, entities);
else
decl = AstNode.MakeImportDecl(entities[0], alias);
}
public SyntaxList <UsingDirectiveSyntax> Convert(ImportDeclaration node)
{
return(node.ImportClause.ToCsNode <SyntaxList <UsingDirectiveSyntax> >());
}
protected internal override void VisitImportDeclaration(ImportDeclaration importDeclaration)
{
VisitingImportDeclaration?.Invoke(this, importDeclaration);
base.VisitImportDeclaration(importDeclaration);
VisitedImportDeclaration?.Invoke(this, importDeclaration);
}
protected override void VisitImportDeclaration(ImportDeclaration importDeclaration)
{
_substitutions.Add(importDeclaration.Range, StringSegment.Empty);
}
public void VisitImportDeclaration(ImportDeclaration importDecl)
{
// An import declaration always introduces new variable(s) into the module scope.
if(importDecl.AliasNameToken.IsNull){
foreach(var entity in importDecl.ImportedEntities){
}
}else{
if(importDecl.AliasNameToken.IsNull)
Define(importDecl.ModuleName);
else
Define(importDecl.AliasName);
}
}
public virtual void VisitImportDeclaration(ImportDeclaration importDeclaration)
{
}
public TypescriptEnum(ImportDeclaration node, string rootDir) : base(node, rootDir)
{
}
/**
* Call back method that must be called as soon as the given <code>
* ImportDeclaration</code> object has been traversed.
*
* @param pImportDeclaration The <code>ImportDeclaration</code> object that
* has just been traversed.
*/
public void actionPerformed(
ImportDeclaration pImportDeclaration)
{
// Nothing to do.
}
public virtual T VisitImportDeclaration(ImportDeclaration importDeclaration)
{
return(VisitChildren(importDeclaration));
}
public void VisitImportDeclaration(ImportDeclaration importDecl)
{
// Here's the good place to import names from other files
// All external names will be imported into the module scope we are currently compiling
if(importDecl.AliasNameToken.IsNull){
importDecl.ModuleNameToken.AcceptWalker(this);
foreach(var ie in importDecl.ImportedEntities)
UniqueIdGenerator.DefineNewId(ie.AsIdentifier);
}else{
importDecl.ModuleNameToken.AcceptWalker(this);
UniqueIdGenerator.DefineNewId(importDecl.AliasNameToken);
}
}
public TypescriptProperty(ImportDeclaration node, string rootDir) : base(node, rootDir)
{
}
