Example #1
0
        private bool TryAutoAddAssemblyReference(Boo.Lang.Compiler.Ast.Import import)
        {
            Assembly asm = Parameters.FindAssembly(import.Namespace);

            if (asm != null)
            {
                return(false);                         //name resolution already failed earlier, don't try twice
            }
            asm = Parameters.LoadAssembly(import.Namespace, false);
            if (asm == null)
            {
                return(false);
            }

            if (asm != null)
            {
                try
                {
                    NameResolutionService.OrganizeAssemblyTypes(asm);
                }
                catch (Exception /*ignored*/)
                {
                    return(false);
                }
                Parameters.AddAssembly(asm);
                import.AssemblyReference        = new ReferenceExpression(import.LexicalInfo, import.Namespace);
                import.AssemblyReference.Entity = new AssemblyReference(asm);
                return(true);
            }
            return(false);
        }
 /// <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);
     }
 }
Example #3
0
        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;
		}
Example #6
0
        public override void OnImport(AST.Import p)
        {
            DefaultUsing u = new DefaultUsing(_cu.ProjectContent);

            if (p.Alias == null)
            {
                u.Usings.Add(p.Namespace);
            }
            else
            {
                u.AddAlias(p.Alias.Name, new GetClassReturnType(_cu.ProjectContent, p.Namespace, 0));
            }
            _cu.UsingScope.Usings.Add(u);
        }
Example #7
0
 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);
 }
Example #8
0
		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;
		}
Example #9
0
        private bool TryAutoAddAssemblyReference(Boo.Lang.Compiler.Ast.Import import)
        {
            ICompileUnit asm = Parameters.FindAssembly(import.Namespace);

            if (asm != null)
            {
                return(false);                //name resolution already failed earlier, don't try twice
            }
            asm = Parameters.LoadAssembly(import.Namespace, false);
            if (asm == null)
            {
                //try generalized namespaces
                string[] namespaces = import.Namespace.Split(new char[] { '.', });
                if (namespaces.Length == 1)
                {
                    return(false);
                }
                string ns;
                int    level = namespaces.Length - 1;
                while (level > 0)
                {
                    ns  = string.Join(".", namespaces, 0, level);
                    asm = Parameters.FindAssembly(ns);
                    if (asm != null)
                    {
                        return(false);                                 //name resolution already failed earlier, don't try twice
                    }
                    asm = Parameters.LoadAssembly(ns, false);
                    if (asm != null)
                    {
                        break;
                    }
                    level--;
                }
            }

            if (asm != null)
            {
                Parameters.References.Add(asm);
                import.AssemblyReference        = new ReferenceExpression(import.LexicalInfo, asm.FullName);
                import.AssemblyReference.Entity = asm;

                NameResolutionService.ClearResolutionCacheFor(asm.Name);
                return(true);
            }
            return(false);
        }
Example #10
0
		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;
		}
Example #11
0
        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);
        }
Example #13
0
        public override void OnImport(Boo.Lang.Compiler.Ast.Import import)
        {
            if (IsAlreadyBound(import))
            {
                return;
            }

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

            var entity = ResolveImport(import);

            if (HandledAsImportError(import, entity) || HandledAsDuplicatedNamespace(import, entity))
            {
                return;
            }

            Context.TraceInfo("{1}: import reference '{0}' bound to {2}.", import, import.LexicalInfo, entity.FullName);
            import.Entity = ImportedNamespaceFor(import, entity);
        }
Example #14
0
 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;
 }
Example #15
0
        private bool TryAutoAddAssemblyReference(Import import)
        {
            var existingReference = Parameters.FindAssembly(import.Namespace);
            if (existingReference != null)
                return false;

            var asm = TryToLoadAssemblyContainingNamespace(import.Namespace);
            if (asm == null)
                return false;

            Parameters.References.Add(asm);
            import.AssemblyReference = new ReferenceExpression(import.LexicalInfo, asm.FullName).WithEntity(asm);
            NameResolutionService.ClearResolutionCacheFor(asm.Name);
            return true;
        }
Example #16
0
        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);
        }
Example #17
0
 private IEntity ResolveImportAgainstReferencedAssembly(Import import)
 {
     return NameResolutionService.ResolveQualifiedName(GetBoundReference(import.AssemblyReference).RootNamespace, import.Namespace);
 }
Example #18
0
 public static CompilerError InvalidNamespace(Import import)
 {
     return new CompilerError("BCE0021", import.LexicalInfo, import.Namespace);
 }
Example #19
0
 public static CompilerError InvalidNamespace(Import import)
 {
     if (import.AssemblyReference != null)
         return Instantiate("BCE0167", import, import.Namespace, import.AssemblyReference);
     return Instantiate("BCE0021", import, import.Namespace);
 }
Example #20
0
        private bool HandledAsDuplicatedNamespace(Import import)
        {
            var actualName = EffectiveNameForImportedNamespace(import);

            //only add unique namespaces
            Import cachedImport;
            if (!_namespaces.TryGetValue(actualName, out cachedImport))
            {
                _namespaces[actualName] = import;
                return false;
            }

            //ignore for partial classes in separate files
            if (cachedImport.LexicalInfo.FileName == import.LexicalInfo.FileName)
                Warnings.Add(CompilerWarningFactory.DuplicateNamespace(import, import.Namespace));

            BindError(import);
            return true;
        }
Example #21
0
 private static string EffectiveNameForImportedNamespace(Import import)
 {
     return null != import.Alias ? import.Alias.Name : 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);
        }
Example #23
0
 private void BindError(Import import)
 {
     Bind(import, Error.Default);
 }
Example #24
0
	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;
	}
        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);
                    }
                }
            }
        }
Example #26
0
 public override void OnImport(Import node)
 {
     if (node.LexicalInfo != null)
         results.MapParsedNode(new MappedImport(results, node));
     base.OnImport(node);
 }
        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);
        }
Example #28
0
        private IEntity ImportedNamespaceFor(Import import, IEntity entity)
        {
            var ns = entity as INamespace;
            if (ns == null)
                return entity;

            var selectiveImportSpec = import.Expression as MethodInvocationExpression;
            var imported = selectiveImportSpec != null ? SelectiveImportFor(ns, selectiveImportSpec) : ns;
            var actualNamespace = null != import.Alias ? AliasedNamespaceFor(imported, import) : imported;
            return new ImportedNamespace(import, actualNamespace);
        }
Example #29
0
 private static INamespace AliasedNamespaceFor(IEntity entity, Import import)
 {
     var aliasedNamespace = new AliasedNamespace(import.Alias.Name, entity);
     import.Alias.Entity = aliasedNamespace;
     return aliasedNamespace;
 }
Example #30
0
 private void ImportError(Import import, CompilerError error)
 {
     Errors.Add(error);
     BindError(import);
 }
Example #31
0
 private static bool IsAlreadyBound(Import import)
 {
     return import.Entity != null;
 }
Example #32
0
 private void ImportFromAssemblyReference(Import import)
 {
     var resolvedNamespace = ResolveImportAgainstReferencedAssembly(import);
     if (HandledAsImportError(import, resolvedNamespace))
         return;
     if (HandledAsDuplicatedNamespace(import))
         return;
     import.Entity = ImportedNamespaceFor(import, resolvedNamespace);
 }
Example #33
0
	protected Import  import_directive_() //throws RecognitionException, TokenStreamException
{
		Import returnValue;
		
		IToken  imp = null;
		IToken  dqs = null;
		IToken  sqs = null;
		IToken  alias = null;
		
			Expression ns = null;
			IToken id = null;
			returnValue = null;
		
		
		try {      // for error handling
			imp = LT(1);
			match(IMPORT);
			ns=namespace_expression();
			if (0==inputState.guessing)
			{
				if (ns != null) returnValue = new Import(ToLexicalInfo(imp), ns);
			}
			{
				switch ( LA(1) )
				{
				case FROM:
				{
					match(FROM);
					{
						switch ( LA(1) )
						{
						case THEN:
						case ID:
						{
							id=identifier();
							break;
						}
						case DOUBLE_QUOTED_STRING:
						{
							dqs = LT(1);
							match(DOUBLE_QUOTED_STRING);
							if (0==inputState.guessing)
							{
								id=dqs;
							}
							break;
						}
						case SINGLE_QUOTED_STRING:
						{
							sqs = LT(1);
							match(SINGLE_QUOTED_STRING);
							if (0==inputState.guessing)
							{
								id=sqs;
							}
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						 }
					}
					if (0==inputState.guessing)
					{
						
									returnValue.AssemblyReference = new ReferenceExpression(ToLexicalInfo(id), id.getText());
								
					}
					break;
				}
				case EOL:
				case AS:
				case EOS:
				case QQ_END:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			{
				switch ( LA(1) )
				{
				case AS:
				{
					match(AS);
					alias = LT(1);
					match(ID);
					if (0==inputState.guessing)
					{
						
									returnValue.Alias = new ReferenceExpression(ToLexicalInfo(alias));
									returnValue.Alias.Name = alias.getText();
								
					}
					break;
				}
				case EOL:
				case EOS:
				case QQ_END:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "import_directive_");
				recover(ex,tokenSet_23_);
			}
			else
			{
				throw ex;
			}
		}
		return returnValue;
	}
Example #34
0
        public override void OnImport(Boo.Lang.Compiler.Ast.Import import)
        {
            INamespace oldns  = NameResolutionService.CurrentNamespace;
            IEntity    entity = null;

            try
            {
                NameResolutionService.EnterNamespace(NameResolutionService.CurrentNamespace.ParentNamespace);
                entity = NameResolutionService.ResolveQualifiedName(import.Namespace);
            }
            finally
            {
                NameResolutionService.EnterNamespace(oldns);
            }

            if (null == entity)
            {
                entity = NameResolutionService.ResolveQualifiedName(import.Namespace);
            }

            //if 'import X', try 'import X from X'
            //comment out next if block if this is not wanted
            if (null == entity && null == import.AssemblyReference)
            {
                if (TryAutoAddAssemblyReference(import))
                {
                    entity = NameResolutionService.ResolveQualifiedName(import.Namespace);
                }
            }

            if (null == entity)
            {
                Errors.Add(CompilerErrorFactory.InvalidNamespace(import));
                entity = TypeSystemServices.ErrorEntity;
            }
            else
            {
                if (!IsValidNamespace(entity))
                {
                    Errors.Add(CompilerErrorFactory.NotANamespace(import, entity.FullName));
                    entity = TypeSystemServices.ErrorEntity;
                }
                else
                {
                    string name = entity.FullName;
                    if (null != import.AssemblyReference)
                    {
                        NamespaceEntity nsInfo = entity as NamespaceEntity;
                        if (null != nsInfo)
                        {
                            entity = new AssemblyQualifiedNamespaceEntity(GetBoundAssembly(import.AssemblyReference), nsInfo);
                        }
                    }

                    if (null != import.Alias)
                    {
                        entity = new AliasedNamespace(import.Alias.Name, entity);
                        import.Alias.Entity = entity;
                        name = entity.Name;                         //use alias name instead of namespace name
                    }

                    //only add unique namespaces
                    Import cachedImport = nameSpaces[name] as Import;
                    if (cachedImport == null)
                    {
                        nameSpaces[name] = import;
                    }
                    else
                    {
                        //ignore for partial classes in separate files
                        if (cachedImport.LexicalInfo.FileName == import.LexicalInfo.FileName)
                        {
                            Warnings.Add(CompilerWarningFactory.DuplicateNamespace(
                                             import, import.Namespace));
                        }
                        RemoveCurrentNode();
                        return;
                    }
                }
            }

            _context.TraceInfo("{1}: import reference '{0}' bound to {2}.", import, import.LexicalInfo, entity.FullName);
            import.Entity = entity;
        }
Example #35
0
 public override void LeaveImport(Import node)
 {
     if (null != node.Alias)
         CheckName(node,node.Alias.Name);
 }
        public override void OnImport(Import node)
        {
            // this is a bit nasty - get all the members of the referenced namespace
            // then push them on the tree, so they're referencable
            var ns = (INamespace)TypeSystemServices.GetEntity(node);

            currentDocument.Imports[node.Namespace] = new ImportedNamespaceTreeNode(new EntitySourceOrigin((IEntity)ns));

            base.OnImport(node);
        }