public ImportStatementCompletionProvider( ICompletionDataGenerator gen, ImportStatement.Import imp) : base(gen) { this.imp = imp; }
public ImportStatementCompletionProvider( ICompletionDataGenerator gen, ImportStatement.ImportBindings imbBind) : base(gen) { this.impBind = imbBind; imp = impBind.Module; }
// ImportStatement public override bool Walk(ImportStatement node) { return(false); }
public ulong Visit(ImportStatement importStatement) { return(1000291); }
public RemovedImportStatement(ImportStatement removed) { _import = removed; }
public override object Visit(ImportStatement that, object value = null) { /** \todo Somehow import an existing scope. */ return null; }
// ImportStatement public virtual bool Walk(ImportStatement node) { return true; }
public override object Visit(ImportStatement that, object value) { _writer.Write("import "); that.Location.Visit(this); _writer.Write(" is "); that.Name.Visit(this); _writer.WriteLine(); return null; }
bool HandleNonAliasedImport(ImportStatement.Import imp, MemberFilter VisibleMembers) { if (imp == null || imp.ModuleIdentifier == null) return false; DModule mod; var thisModuleName = (ctxt.ScopedBlock != null && (mod=ctxt.ScopedBlock.NodeRoot as DModule)!=null) ? mod.ModuleName : string.Empty; if(string.IsNullOrEmpty(thisModuleName)) return false; var moduleName = imp.ModuleIdentifier.ToString(); List<string> seenModules = null; if (!scannedModules.TryGetValue(thisModuleName, out seenModules)) seenModules = scannedModules[thisModuleName] = new List<string>(); else if (seenModules.Contains(moduleName)) return false; seenModules.Add(moduleName); var scAst = ctxt.ScopedBlock == null ? null : ctxt.ScopedBlock.NodeRoot as DModule; if (ctxt.ParseCache != null) foreach (var module in ctxt.ParseCache.LookupModuleName(moduleName)) //TODO: Only take the first module? Notify the user about ambigous module names? { if (module == null || (scAst != null && module.FileName == scAst.FileName && module.FileName != null)) continue; //ctxt.PushNewScope(module); if(ScanImportedModule(module as DModule,VisibleMembers)) { //ctxt.Pop(); return true; } //ctxt.Pop(); } return false; }
/// <summary> /// Visits a <see cref="ImportStatement"/>. /// </summary> /// <param name="node"> /// The node. /// </param> /// <returns> /// The node, or a new version of the node. /// </returns> protected internal override Node VisitImportStatement(ImportStatement node) { return(this.VisitImplementation(node) ?? base.VisitImportStatement(node)); }
public override bool Walk(ImportStatement node) { writer.WriteLine("Import: " + GetImports(node.Names)); return(base.Walk(node)); }
public override bool Walk(ImportStatement node) => ImportHandler.HandleImport(node);
// ImportStatement public override bool Walk(ImportStatement node) { return(Location >= node.StartIndex && Location <= node.EndIndex); }
public void Visit(ImportStatement node) { // starts with import, so we don't care }
// ImportStatement public virtual bool Walk(ImportStatement node) { return(true); }
public override bool Walk(ImportStatement node) => Save(node, base.Walk(node), "import");
public void Register(ImportStatement importStatement) { Register(this, importStatement.Library, importStatement.Imports); }
ImportStatement.ImportBindings ImportBindings(ImportStatement.Import imp) { var importBindings = new ImportStatement.ImportBindings { Module=imp }; LastParsedObject = importBindings; bool init = true; while (laKind == Comma || init) { if (init) init = false; else Step(); if (Expect(Identifier)) { var symbolAlias = new IdentifierDeclaration(t.Value){ Location = t.Location, EndLocation = t.EndLocation }; if (laKind == Assign) { Step(); if (Expect (Identifier)) importBindings.SelectedSymbols.Add (new ImportStatement.ImportBinding (new IdentifierDeclaration (t.Value) { Location = t.Location, EndLocation = t.EndLocation }, symbolAlias)); } else importBindings.SelectedSymbols.Add(new ImportStatement.ImportBinding(symbolAlias)); } } if (!IsEOF) LastParsedObject = null; return importBindings; }
public void StatementCreatorOrderTest() { DBTable table = new DBTable("dbo", "TestTable"); DBColumn col1 = new DBColumn(table, "TestCol1", true, DBDatatype.integer); DBColumn col2 = new DBColumn(table, "TestCol2", false, DBDatatype.nvarchar); DBColumn col3 = new DBColumn(table, "TestCol3", false, DBDatatype.integer); table.Columns = new List <DBColumn>() { col1, col2, col3 }; Database db = new Database("TestDB", new List <DBTable>() { table }); TableMapping sourceTablemapping = new TableMapping(new DBTable("dbo", "TestTable2"), TableMappingImportType.Insert, null); ColumnMapping colMap1 = new TableColumnMapping(sourceTablemapping, col1, col1, ColumnUse.Where); ColumnMapping colMap2 = new LiteralColumnMapping("2", LiteralType.String, col2, ColumnUse.Where); ColumnMapping colMap3 = new LiteralColumnMapping("3", LiteralType.String, col2, ColumnUse.Set); TableMapping tableMapping = new TableMapping(table, TableMappingImportType.Update, new ColumnMapping[] { colMap1, colMap2, colMap3 }); ErrorHandling errorHandling = new ErrorHandling(); ImportConfiguration config = new ImportConfiguration(new TableMapping[] { tableMapping }, null, "TestDB", errorHandling); SourceDataEntry[] entries = new SourceDataEntry[] { SourceDataEntry.CreateDataEntry("", DataType.String, "") }; SourceDataRow[] rows = new SourceDataRow[] { new SourceDataRow(entries, "0") }; SourceDataTable dt = new SourceDataTable(rows, new string[] { "" }); SQLServerStatementCreator statementCreator = new SQLServerStatementCreator(config, dt); ImportStatement statement = statementCreator.CreateStatement(0); ImportStatement[] statements = statementCreator.CreateStatements(); Assert.AreEqual(1, statements.Length); Assert.AreEqual(statement.RowReference, statements[0].RowReference); Assert.AreEqual(statement.SqlStatement, statements[0].SqlStatement); string[] lines = statement.SqlStatement .Split(new string[] { "\n" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray(); StatementSetupPart setupPart = new StatementSetupPart(config); Assert.AreEqual(setupPart.GetDatabasePart(), lines[0]); Assert.AreEqual(setupPart.GetWarningsPart(), lines[1]); StatementTransactionPart transPart = new StatementTransactionPart(config); string[] transStartPart = transPart.GetTransactionStartPart() .Split(new string[] { "\n" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray();; Assert.AreEqual(2, transStartPart.Length); Assert.AreEqual(transStartPart[0], lines[2]); Assert.AreEqual(transStartPart[1], lines[3]); StatementTableMappingPart tmParts = new StatementTableMappingPart(tableMapping, dt.GetDataRow(0)); string variablePart = tmParts.GetTableVariablePart().Replace("\n", ""); Assert.AreEqual(variablePart, lines[4]); string[] bodyParts = tmParts.GetStatementBodyPart() .Split(new string[] { "\n" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray(); Assert.AreEqual(4, bodyParts.Length); Assert.AreEqual(bodyParts[0], lines[5]); Assert.AreEqual(bodyParts[1], lines[6]); Assert.AreEqual(bodyParts[2], lines[7]); Assert.AreEqual(bodyParts[3], lines[8]); string[] transEndPart = transPart.GetTransactionEndPart() .Split(new string[] { "\n" }, StringSplitOptions.None).Where(s => s.Length > 0).ToArray(); Assert.AreEqual(12, transEndPart.Length); Assert.AreEqual(transEndPart[0], lines[9]); Assert.AreEqual(transEndPart[1], lines[10]); Assert.AreEqual(transEndPart[2], lines[11]); Assert.AreEqual(transEndPart[3], lines[12]); Assert.AreEqual(transEndPart[4], lines[13]); Assert.AreEqual(transEndPart[5], lines[14]); Assert.AreEqual(transEndPart[6], lines[15]); Assert.AreEqual(transEndPart[7], lines[16]); Assert.AreEqual(transEndPart[8], lines[17]); Assert.AreEqual(transEndPart[9], lines[18]); Assert.AreEqual(transEndPart[10], lines[19]); Assert.AreEqual(transEndPart[11], lines[20]); }
public void VisitImport(ImportStatement i) { foreach (var name in i.names) { if (name.alias == null) { gen.Using(name.orig.ToString()); } else { gen.Using( name.alias.Name, string.Join( ".", name.orig.segs.Concat(new[] { name.alias }) .Select(s => gen.EscapeKeywordName(s.Name)))); } } }
public PythonImport(IProjectContent projectContent, ImportStatement importStatement) : base(projectContent) { this.importStatement = importStatement; AddUsings(); }
// ImportStatement public override bool Walk(ImportStatement node) { return false; }
protected internal override Node VisitImportStatement([NotNull] ImportStatement node) { this.Builder.Append($"IMPORT '{node.Uri}'"); return(node); }
public void Visit(ImportStatement node) { // not applicable; terminate }
// ImportStatement public override bool Walk(ImportStatement node) { return(ShouldWalkWorker(node)); }
public UpdatedImportStatement(ImportStatement import) { _import = import; }
public override void PostWalk(ImportStatement node) { PostWalkWorker(node); }
public override bool Walk(ImportStatement node) { int len = Math.Min(node.Names.Count, node.AsNames.Count); for (int i = 0; i < len; i++) { var curName = node.Names[i]; var asName = node.AsNames[i]; string importing, saveName; Node nameNode; if (curName.Names.Count == 0) { continue; } else if (curName.Names.Count > 1) { // import fob.oar if (asName != null) { // import fob.oar as baz, baz becomes the value of the oar module importing = curName.MakeString(); saveName = asName.Name; nameNode = asName; } else { // plain import fob.oar, we bring in fob into the scope saveName = importing = curName.Names[0].Name; nameNode = curName.Names[0]; } } else { // import fob importing = curName.Names[0].Name; if (asName != null) { saveName = asName.Name; nameNode = asName; } else { saveName = importing; nameNode = curName.Names[0]; } } ModuleReference modRef; var def = Scope.CreateVariable(nameNode, _unit, saveName); if (TryImportModule(importing, node.ForceAbsolute, out modRef)) { modRef.AddReference(_unit.DeclaringModule); Debug.Assert(modRef.Module != null); if (modRef.Module != null) { modRef.Module.Imported(_unit); if (modRef.AnalysisModule != null) { def.AddTypes(_unit, modRef.AnalysisModule); } def.AddAssignment(nameNode, _unit); } } } return(true); }
public SymbolTable VisitImport(ImportStatement i) { throw new NotImplementedException(); }
public override void PostWalk(ImportStatement node) { }
public void Visit(ImportStatement importStatement) { }
public virtual void PostWalk(ImportStatement node) { }
public ImportResult(ImportStatement statement) { this.statement = statement; }
// ImportStatement public override bool Walk(ImportStatement node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
public SuccesfulImport(ImportStatement statement, int rowsAffected) : base(statement) { this.rowsAffected = rowsAffected; }
ImportStatement ImportDeclaration(IBlockNode scope) { // In DMD 2.060, the static keyword must be written exactly before the import token bool isStatic = t!= null && t.Kind == Static; bool isPublic = Modifier.ContainsAttribute(DeclarationAttributes, Public) || Modifier.ContainsAttribute(BlockAttributes,Public); Expect(Import); var importStatement = new ImportStatement { Attributes = GetCurrentAttributeSet_Array(), Location=t.Location, IsStatic = isStatic, IsPublic = isPublic }; DeclarationAttributes.Clear(); var imp = _Import(); while (laKind == Comma) { importStatement.Imports.Add(imp); Step(); imp = _Import(); } if (laKind == Colon) { Step(); importStatement.ImportBindList = ImportBindings(imp); } else importStatement.Imports.Add(imp); // Don't forget to add the last import if (Expect(Semicolon)) LastParsedObject = null; CheckForPostSemicolonComment(); importStatement.EndLocation = t.EndLocation; // Prepare for resolving external items importStatement.CreatePseudoAliases(scope); return importStatement; }
public UnsuccesfulImport(ImportStatement statement, string errorMsg) : base(statement) { this.errorMsg = errorMsg; }
public override object Visit(ImportStatement that, object value = null) { PrintPrologue(that); PrintDefinition(that); PrintNodeId("Location", that.Location); PrintEpilogue(that); that.Name.Visit(this); that.Location.Visit(this); return null; }
public override bool Walk(ImportStatement node) { int len = Math.Min(node.Names.Count, node.AsNames.Count); for (int i = 0; i < len; i++) { var curName = node.Names[i]; var asName = node.AsNames[i]; string importing, saveName; NameExpression nameNode; if (curName.Names.Count == 0) { continue; } else if (curName.Names.Count > 1) { // import fob.oar if (asName != null) { // import fob.oar as baz, baz becomes the value of the oar module importing = curName.MakeString(); saveName = asName.Name; nameNode = asName; } else { // plain import fob.oar, we bring in fob into the scope saveName = importing = curName.Names[0].Name; nameNode = curName.Names[0]; } } else { // import fob importing = curName.Names[0].Name; if (asName != null) { saveName = asName.Name; nameNode = asName; } else { saveName = importing; nameNode = curName.Names[0]; } } // Ensure a variable exists, even if the import fails Scope.CreateVariable(nameNode, _unit, saveName); if (!TryImportModule(importing, node.ForceAbsolute, out var modRef, out var bits)) { _unit.DeclaringModule.AddUnresolvedModule(importing, node.ForceAbsolute); continue; } _unit.DeclaringModule.AddModuleReference(modRef); var userMod = modRef.Module; Debug.Assert(userMod != null); if (userMod != null) { userMod.Imported(_unit); AssignImportedModule(nameNode, modRef, bits, saveName); } } return(true); }
public void VisitImport(ImportStatement i) { throw new NotImplementedException(); }
public ImportDefinition(DottedName name, ImportStatement import) { this.name = name; this.importStatement = import; }
public virtual void Visit(ImportStatement s) { VisitAbstractStmt(s); }
public override bool Walk(ImportStatement node) { UpdateLineInfo(node); return(base.Walk(node)); }
private List <Inferred> InferImportStatement(ImportStatement node, Scope scope) { Debug.Print("Not implemented: InferImportStatementIn"); return(null); }
public virtual object Visit(ImportStatement that, object value) { throw new System.NotImplementedException(); }