/// <summary>
 /// Add the namespaces to the module
 /// </summary>
 public override void OnModule(Module node)
 {
     foreach (string ns in namespaces)
     {
         Import import = new Import(node.LexicalInfo, ns);
         node.Imports.Add(import);
     }
 }

        IEnumerable<Import> ImportTasks(Import import)
        {
            if (import.AssemblyReference == null)
                throw new InvalidOperationException("Cannot import tasks: 'from' assembly is not specified.");

            return from importer in importers
                   from newImport in importer.BuildImportsFrom(import.AssemblyReference.Name)
                   select newImport;
        }

 public override void OnModule(Module node)
 {
     var imports = new[] { "UnityEngine", "System.Collections" };
     foreach (var importName in imports)
     {
         var targetImport = new Import(LexicalInfo.Empty, importName);
         if (node.Imports.Contains(targetImport))
             node.Imports.Add(targetImport);
     }
 }

		public object VisitUsing(Using @using, object data)
		{
			B.Import import;
			if (@using.IsAlias) {
				import = new B.Import(@using.Alias.Type, null, new B.ReferenceExpression(@using.Name));
				import.LexicalInfo = GetLexicalInfo(@using);
			} else {
				import = new B.Import(GetLexicalInfo(@using), @using.Name);
			}
			module.Imports.Add(import);
			return import;
		}

		private bool HandledAsImportError(Import import, IEntity entity)
		{
			if (entity == null)
			{
				ImportError(import, CompilerErrorFactory.InvalidNamespace(import));
				return true;
			}

			if (!IsValidImportTarget(entity))
			{
				ImportError(import, CompilerErrorFactory.NotANamespace(import, entity));
				return true;
			}

			return false;
		}

		private bool HandledAsImportError(Import import, IEntity entity)
		{
			if (null == entity)
			{
				Errors.Add(CompilerErrorFactory.InvalidNamespace(import));
				BindError(import);
				return true;
			}

			if (!IsValidNamespace(entity))
			{
				Errors.Add(CompilerErrorFactory.NotANamespace(import, entity.FullName));
				BindError(import);
				return true;
			}
			return false;
		}

        public override void OnImport(Import import)
        {
            if (IsAlreadyBound(import))
                return;

            if (import.AssemblyReference != null)
            {
                ImportFromAssemblyReference(import);
                return;
            }

            var entity = ResolveImport(import);
            if (HandledAsImportError(import, entity) || HandledAsDuplicatedNamespace(import))
                return;

            Context.TraceInfo("{1}: import reference '{0}' bound to {2}.", import, import.LexicalInfo, entity);
            import.Entity = ImportedNamespaceFor(import, entity);
        }

        public override void OnModule(Module node){
            logger.get("comdiv.dsl").Debug("SetupDefaultNamespacesAndReferencesStep on {0} started", node.Name);
            Console.WriteLine("SetupDefaultNamespacesAndReferencesStep on {0} started", node.Name);
            if(null==node.Namespace){
                node.Namespace = new NamespaceDeclaration(System.IO.Path.GetFileNameWithoutExtension(Context.Parameters.OutputAssembly));
            }
            if (null != namespaces){
                foreach (var ns in namespaces){
                    var import = new Import();
                    import.Namespace = ns;
                    node.Imports.Add(import);
                    logger.get("comdiv.dsl").Debug("SetupDefaultNamespacesAndReferencesStep on {0} - {1} ns added", node.Name, ns);
                    Console.WriteLine("SetupDefaultNamespacesAndReferencesStep on {0} - {1} ns added", node.Name, ns);
                }
            }

            logger.get("comdiv.dsl").Debug("SetupDefaultNamespacesAndReferencesStep on {0} finished", node.Name);
        }

	protected Import  import_directive_from_() //throws RecognitionException, TokenStreamException
{
		Import returnValue;
		
		IToken  from = null;
		
			Expression ns = null;
			ExpressionCollection names = null;
			returnValue = null;
		
		
		try {      // for error handling
			from = LT(1);
			match(FROM);
			ns=identifier_expression();
			match(IMPORT);
			if (0==inputState.guessing)
			{
				
						var mie = new MethodInvocationExpression(ns);
						names = mie.Arguments;
						returnValue = new Import(ToLexicalInfo(from), mie);
					
			}
			{
				if ((LA(1)==MULTIPLY) && (LA(2)==EOL||LA(2)==EOS))
				{
					match(MULTIPLY);
					if (0==inputState.guessing)
					{
						returnValue.Expression = ns;
					}
				}
				else if ((tokenSet_24_.member(LA(1))) && (tokenSet_25_.member(LA(2)))) {
					expression_list(names);
				}
				else
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				
			}
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "import_directive_from_");
				recover(ex,tokenSet_19_);
			}
			else
			{
				throw ex;
			}
		}
		return returnValue;
	}

 public static CompilerError InvalidNamespace(Import import)
 {
     return new CompilerError("BCE0021", import.LexicalInfo, import.Namespace);
 }

 private static string EffectiveNameForImportedNamespace(Import import)
 {
     return null != import.Alias ? import.Alias.Name : import.Namespace;
 }

 private IEntity ResolveImportOnParentNamespace(Import import)
 {
     var current = NameResolutionService.CurrentNamespace;
     try
     {
         INamespace parentNamespace = NameResolutionService.CurrentNamespace.ParentNamespace;
         if (parentNamespace != null)
         {
             NameResolutionService.EnterNamespace(parentNamespace);
             return NameResolutionService.ResolveQualifiedName(import.Namespace);
         }
     }
     finally
     {
         NameResolutionService.EnterNamespace(current);
     }
     return null;
 }

        private IEntity ResolveImport(Import import)
        {
            var entity = ResolveImportOnParentNamespace(import) ?? NameResolutionService.ResolveQualifiedName(import.Namespace);
            if (null != entity)
                return entity;

            //if 'import X', try 'import X from X'
            if (!TryAutoAddAssemblyReference(import))
                return null;

            return NameResolutionService.ResolveQualifiedName(import.Namespace);
        }

        private void AddFileReference(Import node)
        {
            RemoveCurrentNode();

            //we may need to preserve this, since it may be used in several compiler cycles.
            //which will set them to different things
            CompilerErrorCollection errors = Errors;
            AssemblyCollection references = Parameters.References;
            string url = GetFilePath(node);

            Assembly assembly;
            if (assemblyCache.TryGetValue(url, out assembly) == false)
            {
                assembly = CompileAssembly(node, url, errors);

                if (assembly == null)
                {
                    throw new CompilationErrorsException(errors);
                }

                assemblyCache.Add(url, assembly);
            }

            references.Add(assembly);
        }

        private static string GetFilePath(Import node)
        {
            // assume this is located relative to the current file
            if (node.LexicalInfo != null &&
                File.Exists(node.LexicalInfo.FullPath))
            {
                string directory = Path.GetDirectoryName(node.LexicalInfo.FullPath);
                return Path.Combine(directory, node.AssemblyReference.Name);
            }

            return node.AssemblyReference.Name
                .Replace("~", AppDomain.CurrentDomain.BaseDirectory);
        }

 private void ImportError(Import import, CompilerError error)
 {
     Errors.Add(error);
     BindError(import);
 }

 private void ImportFromAssemblyReference(Import import)
 {
     var resolvedNamespace = ResolveImportAgainstReferencedAssembly(import);
     if (HandledAsImportError(import, resolvedNamespace))
         return;
     if (HandledAsDuplicatedNamespace(import))
         return;
     import.Entity = ImportedNamespaceFor(import, resolvedNamespace);
 }

        private void AddNamespaceImports(Import node)
        {
            RemoveCurrentNode();

            string url = GetFilePath(node);
            using(TextReader reader = urlResolver(url, baseDirectory))
            {
                BooParsingStep parser = new BooParsingStep();
                CompilerContext context = new CompilerContext();
                StringInput input = new StringInput(node.AssemblyReference.Name, reader.ReadToEnd());
                context.Parameters.Input.Add(input);
                parser.Initialize(context);
                parser.Run();
                Module current = (Module) node.GetAncestor(NodeType.Module);
                foreach (Module module in context.CompileUnit.Modules)
                {
                    foreach (Import import in module.Imports)
                    {
                        current.Imports.Add(import);
                    }
                }
            }
        }

 private IEntity ResolveImportAgainstReferencedAssembly(Import import)
 {
     return NameResolutionService.ResolveQualifiedName(GetBoundReference(import.AssemblyReference).RootNamespace, import.Namespace);
 }

 public static CompilerError InvalidNamespace(Import import)
 {
     if (import.AssemblyReference != null)
         return Instantiate("BCE0167", import, import.Namespace, import.AssemblyReference);
     return Instantiate("BCE0021", import, import.Namespace);
 }