internal WebPiReferenceNode(ProjectNode root, ProjectElement element, string filename, string productId, string friendlyName)
     : base(root, element) {
     Utilities.ArgumentNotNullOrEmpty("filename", filename);
     _feed = filename;
     _productId = productId;
     _friendlyName = friendlyName;
 }

 public NodejsFileNode(NodejsProjectNode root, ProjectElement e)
     : base(root, e) {
     if (Url.Contains(AnalysisConstants.NodeModulesFolder)) {
         root.EnqueueForDelayedAnalysis(this);
     } else {
         Analyze();
     }
 }

        internal PythonExtensionReferenceNode(PythonProjectNode root, ProjectElement element, string filename)
            : base(root, element) {
            Utilities.ArgumentNotNullOrEmpty("filename", filename);
            _filename = CommonUtils.GetAbsoluteFilePath(root.ProjectHome, filename);

            AnalyzeReference(root.GetInterpreter() as IPythonInterpreterWithProjectReferences);
            InitializeFileChangeEvents();
        }

        public NodejsFileNode(NodejsProjectNode root, ProjectElement e)
            : base(root, e) {
            string referenceBaseName = Path.GetFileNameWithoutExtension(Caption);

#if FALSE
            CreateWatcher(Url);
#endif
            if (Url.Contains(AnalysisConstants.NodeModulesFolder)) {
                root.DelayedAnalysisQueue.Enqueue(this);
            } else {
                Analyze();
            }
        }

        public NodejsFileNode(NodejsProjectNode root, ProjectElement e)
            : base(root, e) {
            string referenceBaseName = Path.GetFileNameWithoutExtension(Caption);

#if FALSE
            CreateWatcher(Url);
#endif
            if (ShouldAnalyze) {
                root.Analyzer.AnalyzeFile(Url, !IsNonMemberItem);
                root._requireCompletionCache.Clear();
            }
            
            ItemNode.ItemTypeChanged += ItemNode_ItemTypeChanged;
        }

        protected override ReferenceNode CreateReferenceNode(string referenceType, ProjectElement element) {
            if (referenceType == ProjectFileConstants.Reference) {
                string pyExtension = element.GetMetadata(PythonConstants.PythonExtension);
                if (!String.IsNullOrWhiteSpace(pyExtension)) {
                    return new PythonExtensionReferenceNode((PythonProjectNode)ProjectMgr, element, pyExtension);
                }
            } else if (referenceType == ProjectFileConstants.WebPiReference) {
                return new WebPiReferenceNode(
                    ProjectMgr,
                    element,
                    element.GetMetadata("Feed"),
                    element.GetMetadata("ProductId"),
                    element.GetMetadata("FriendlyName")
                );
            }

            return base.CreateReferenceNode(referenceType, element);
        }

        protected override AssemblyReferenceNode CreateAssemblyReferenceNode(ProjectElement element) {
            AssemblyReferenceNode node = null;
            try {
                node = new PythonAssemblyReferenceNode((PythonProjectNode)this.ProjectMgr, element);
            } catch (ArgumentNullException e) {
                Trace.WriteLine("Exception : " + e.Message);
            } catch (FileNotFoundException e) {
                Trace.WriteLine("Exception : " + e.Message);
            } catch (BadImageFormatException e) {
                Trace.WriteLine("Exception : " + e.Message);
            } catch (FileLoadException e) {
                Trace.WriteLine("Exception : " + e.Message);
            } catch (System.Security.SecurityException e) {
                Trace.WriteLine("Exception : " + e.Message);
            }

            return node;
        }

        protected override ReferenceNode CreateReferenceNode(string referenceType, ProjectElement element) {
            if (referenceType == ProjectFileConstants.Reference) {
                if (Path.GetExtension(element.Url).Equals(".pyd", StringComparison.OrdinalIgnoreCase)) {
                    return new DeprecatedReferenceNode(
                        ProjectMgr,
                        element,
                        element.GetMetadata(ProjectFileConstants.Include),
                        Strings.PydReferenceDeprecated
                    );
                }
            } else if (referenceType == ProjectFileConstants.WebPiReference) {
                return new DeprecatedReferenceNode(
                    ProjectMgr,
                    element,
                    element.GetMetadata("FriendlyName"),
                    Strings.WebPIReferenceDeprecated
                );
            }

            return base.CreateReferenceNode(referenceType, element);
        }

 public override CommonFileNode CreateNonCodeFileNode(ProjectElement item)
 {
     return new TrackedFileNode(this, item);
 }

 public override FileNode CreateFileNode(ProjectElement item)
 {
     if (String.IsNullOrEmpty(item.ItemTypeName))
         return base.CreateFileNode(item);
     return CreateTrackedNode(item);
 }

 public PythonFolderNode(CommonProjectNode root, ProjectElement element)
     : base(root, element) {
 }

 /// <summary>
 /// constructor for the ReferenceNode
 /// </summary>
 protected ReferenceNode(ProjectNode root, ProjectElement element)
     : base(root, element) {
     this.ExcludeNodeFromScc = true;
 }

 public BaseFileNode(RustProjectNode node, ProjectElement elm, string path)
     : base(node, elm)
 {
     ProjectMgr = node;
 }

        protected virtual ReferenceNode CreateReferenceNode(string referenceType, ProjectElement element) {
            ReferenceNode node = null;
#if FALSE
            if(referenceType == ProjectFileConstants.COMReference)
            {
                node = this.CreateComReferenceNode(element);
            }
            else 
#endif
            if (referenceType == ProjectFileConstants.Reference) {
                node = this.CreateAssemblyReferenceNode(element);
            } else if (referenceType == ProjectFileConstants.ProjectReference) {
                node = this.CreateProjectReferenceNode(element);
            }

            return node;
        }

 public UntrackedFolderNode(RustProjectNode root, ProjectElement elm)
     : base(root, elm)
 {
     ProjectMgr = root;
 }

 /// <summary>
 /// Constructor for the FolderNode
 /// </summary>
 /// <param name="root">Root node of the hierarchy</param>
 /// <param name="relativePath">relative path from root i.e.: "NewFolder1\\NewFolder2\\NewFolder3</param>
 /// <param name="element">Associated project element</param>
 public FolderNode(ProjectNode root, ProjectElement element)
     : base(root, element) {
 }

 protected internal override FolderNode CreateFolderNode(ProjectElement element)
 {
     if (element == null)
         throw new ArgumentException("element");
     if (element is AllFilesProjectElement || !String.IsNullOrEmpty(element.ItemTypeName))
         return new RustFolderNode(this, element);
     else
         return new UntrackedFolderNode(this, element);
 }

 protected override ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element) {
     return new PythonProjectReferenceNode(ProjectMgr, element);
 }

 private TrackedFileNode CreateTrackedNode(ProjectElement elm)
 {
     var node = new TrackedFileNode(this, elm);
     if (!ModuleTracker.IsIncremental)
     {
         ModuleTracker.AddRootModule(node.Url);
     }
     else
     {
         HashSet<string> children = ModuleTracker.AddRootModuleIncremental(node.Url);
         foreach (string child in children)
         {
             HierarchyNode parent = this.CreateFolderNodes(fs.Path.GetDirectoryName(child), false);
             parent.AddChild(CreateUntrackedNode(child));
         }
     }
     return node;
 }

 public TrackedFileNode(RustProjectNode root, ProjectElement elm)
     : base(root, elm, elm.GetMetadata(ProjectFileConstants.Include))
 {
 }