public ICompletionData CreateEventCreationCompletionData(string varName, IType delegateType, IEvent evt,
                                                          string parameterDefinition,
                                                          IUnresolvedMember currentMember,
                                                          IUnresolvedTypeDefinition currentType)
 {
     return new CompletionData(varName);
 }
Esempio n. 2
0
 public ICompletionData CreateEventCreationCompletionData(string varName, IType delegateType, IEvent evt,
                                                          string parameterDefinition,
                                                          IUnresolvedMember currentMember,
                                                          IUnresolvedTypeDefinition currentType)
 {
     return(new CompletionData(varName));
 }
Esempio n. 3
0
		DefaultUnresolvedMethod ConvertAccessor(Accessor accessor, IUnresolvedMember p, string prefix)
		{
			if (accessor.IsNull)
				return null;
			var a = new DefaultUnresolvedMethod(currentTypeDefinition, prefix + p.Name);
			a.Accessibility = GetAccessibility(accessor.Modifiers) ?? p.Accessibility;
			a.Region = MakeRegion(accessor);
			if (p.EntityType == EntityType.Indexer) {
				foreach (var indexerParam in ((IUnresolvedProperty)p).Parameters)
					a.Parameters.Add(indexerParam);
			}
			DefaultUnresolvedParameter param = null;
			if (accessor.Role == PropertyDeclaration.GetterRole) {
				a.ReturnType = p.ReturnType;
			} else {
				param = new DefaultUnresolvedParameter(p.ReturnType, "value");
				a.Parameters.Add(param);
				a.ReturnType = KnownTypeReference.Void;
			}
			foreach (AttributeSection section in accessor.Attributes) {
				if (section.AttributeTarget == "return") {
					ConvertAttributes(a.ReturnTypeAttributes, section);
				} else if (param != null && section.AttributeTarget == "param") {
					ConvertAttributes(param.Attributes, section);
				} else {
					ConvertAttributes(a.Attributes, section);
				}
			}
			return a;
		}
Esempio n. 4
0
		/// <summary>
		/// Updates the member model with the specified new member.
		/// </summary>
		public void Update(IUnresolvedMember newMember)
		{
			if (newMember == null)
				throw new ArgumentNullException("newMember");
			this.member = newMember;
			RaisePropertyChanged();
		}
        protected void SetOffset(int offset)
        {
            Reset();

            this.offset   = offset;
            this.location = document.GetLocation(offset);

            this.currentType   = CSharpParsedFile.GetInnermostTypeDefinition(location);
            this.currentMember = null;
            if (this.currentType != null)
            {
                foreach (var member in currentType.Members)
                {
                    if (member.Region.Begin < location && (currentMember == null || currentMember.Region.Begin < member.Region.Begin))
                    {
                        currentMember = member;
                    }
                }
            }
            var stack = GetBracketStack(GetMemberTextToCaret().Item1);

            if (stack.Count == 0)
            {
                currentMember = null;
            }
        }
Esempio n. 6
0
        public EventCreationCompletionData(CSharpCompletionTextEditorExtension ext, string varName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType) : base(null)
        {
            if (string.IsNullOrEmpty(varName))
            {
                this.DisplayText = "Handle" + (evt != null ? evt.Name : "");
            }
            else
            {
                this.DisplayText = "Handle" + Char.ToUpper(varName[0]) + varName.Substring(1) + (evt != null ? evt.Name : "");
            }

            if (declaringType != null && declaringType.Members.Any(m => m.Name == this.DisplayText))
            {
                for (int i = 1; i < 10000; i++)
                {
                    if (!declaringType.Members.Any(m => m.Name == this.DisplayText + i))
                    {
                        this.DisplayText = this.DisplayText + i.ToString();
                        break;
                    }
                }
            }
            this.editor        = ext.TextEditorData;
            this.parameterList = parameterList;
            this.callingMember = callingMember;
            this.Icon          = "md-newmethod";
            this.initialOffset = editor.Caret.Offset;
        }
Esempio n. 7
0
        private static IMember ConvertToMember(IUnresolvedMember input)
        {
            IUnresolvedField field = input as IUnresolvedField;

            if (field != null)
            {
                return(new VB6Field(field));
            }

            IUnresolvedMethod method = input as IUnresolvedMethod;

            if (method != null)
            {
                return(new VB6Method(method));
            }

            IUnresolvedProperty property = input as IUnresolvedProperty;

            if (property != null)
            {
                return(new VB6Property(property));
            }

            return(null);
        }
Esempio n. 8
0
 static DomRegion GetValidRegion(IUnresolvedMember member)
 {
     if (member.BodyRegion.IsEmpty || member.DeclaringTypeDefinition.Region.FileName == FilePath.Null)
     {
         return(member.DeclaringTypeDefinition.Region);
     }
     return(member.BodyRegion);
 }
            internal bool IsMatchingMember(IUnresolvedMember member)
            {
                int    rank;
                bool   useDeclaringTypeName = member is IUnresolvedMethod && (((IUnresolvedMethod)member).IsConstructor || ((IUnresolvedMethod)member).IsDestructor);
                string memberName           = useDeclaringTypeName ? member.DeclaringTypeDefinition.Name : member.Name;

                return(MatchName(memberName, out rank));
            }
Esempio n. 10
0
 /// <summary>
 /// Updates the member model with the specified new member.
 /// </summary>
 public void Update(IUnresolvedMember newMember)
 {
     if (newMember == null)
     {
         throw new ArgumentNullException("newMember");
     }
     this.member = newMember;
     RaisePropertyChanged();
 }
Esempio n. 11
0
 public NewPartialCompletionData(int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember member)
 {
     DeclarationBeginningIndex = declarationBegin;
     Type   = type;
     Member = member;
     // check this:
     DeclarationCategory = type.SymbolKind.ResolveDeclarationCategoryFromSymbolKind();
     SetDefaultText(member.Name);
 }
Esempio n. 12
0
        void DoSelectItem(TextLocation location)
        {
            EntityItem matchInside          = null;
            EntityItem nearestMatch         = null;
            int        nearestMatchDistance = int.MaxValue;

            foreach (EntityItem item in classItems)
            {
                if (item.IsInSamePart)
                {
                    IUnresolvedTypeDefinition c = (IUnresolvedTypeDefinition)item.Entity;
                    if (c.Region.IsInside(location.Line, location.Column))
                    {
                        matchInside = item;
                        // when there are multiple matches inside (nested classes), use the last one
                    }
                    else
                    {
                        // Not a perfect match?
                        // Try to first the nearest match. We want the classes combo box to always
                        // have a class selected if possible.
                        int matchDistance = Math.Min(Math.Abs(location.Line - c.Region.BeginLine),
                                                     Math.Abs(location.Line - c.Region.EndLine));
                        if (matchDistance < nearestMatchDistance)
                        {
                            nearestMatchDistance = matchDistance;
                            nearestMatch         = item;
                        }
                    }
                }
            }
            jumpOnSelectionChange = false;
            try {
                classComboBox.SelectedItem = matchInside ?? nearestMatch;
                // the SelectedItem setter will update the list of member items
            } finally {
                jumpOnSelectionChange = true;
            }
            matchInside = null;
            foreach (EntityItem item in memberItems)
            {
                if (item.IsInSamePart)
                {
                    IUnresolvedMember member = (IUnresolvedMember)item.Entity;
                    if (member.Region.IsInside(location.Line, location.Column) || member.BodyRegion.IsInside(location.Line, location.Column))
                    {
                        matchInside = item;
                    }
                }
            }
            jumpOnSelectionChange = false;
            try {
                membersComboBox.SelectedItem = matchInside;
            } finally {
                jumpOnSelectionChange = true;
            }
        }
 public NewPartialCompletionData(int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember member)
 {
     DeclarationBeginningIndex = declarationBegin;
     Type = type;
     Member = member;
     // check this:
     DeclarationCategory = type.SymbolKind.ResolveDeclarationCategoryFromSymbolKind();
     SetDefaultText(member.Name);
 }
Esempio n. 14
0
		public MemberModel(IEntityModelContext context, IUnresolvedMember member)
		{
			if (context == null)
				throw new ArgumentNullException("context");
			if (member == null)
				throw new ArgumentNullException("member");
			this.context = context;
			this.member = member;
		}
		public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
		{
			if (string.IsNullOrEmpty(handlerName)) {
				handlerName = (evt != null ? evt.Name : "Handle");
			}
			this.handlerName = handlerName;
			this.DisplayText = "<Create " + handlerName + ">";
			this.delegateTypeReference = delegateType.ToTypeReference();
			this.isStatic = callingMember != null && callingMember.IsStatic;
		}
		public EventCreationCompletionData(string handlerName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
		{
			if (string.IsNullOrEmpty(handlerName)) {
				handlerName = (evt != null ? evt.Name : "Handle");
			}
			this.handlerName = handlerName;
			this.DisplayText = StringParser.Parse("${res:CSharpBinding.Refactoring.EventCreation.EventHandlerText}", new[] { new StringTagPair("HandlerName", handlerName) });
			this.delegateTypeReference = delegateType.ToTypeReference();
			this.isStatic = callingMember != null && callingMember.IsStatic;
		}
Esempio n. 17
0
        void AddItemIfMatchText(string text, IUnresolvedMember member, IImage image, bool inCurrentFile)
        {
            string name      = member.Name;
            int    matchType = GetMatchType(text, name);

            if (matchType >= 0)
            {
                AddItem(member, image, matchType, inCurrentFile);
            }
        }
Esempio n. 18
0
        /// <summary>
        ///   Initializes a new instance with no child nodes for the
        ///   given member.
        /// </summary>
        public Node(IUnresolvedMember member, IDocument document) {
            this.ChildNodes = null;
            this.Location = QuickFix.ForNonBodyRegion(member, document);

            // Fields' BodyRegion does not include their name for some
            // reason. To prevent the field's name missing, include
            // the whole region for them.
			if (member.SymbolKind == SymbolKind.Field)
                this.Location.Text += member.Name;
        }
Esempio n. 19
0
        /// <summary>
        /// Retrieves the model instance for the given unresolved entity.
        /// </summary>
        /// <param name="entity">The unresolved entity</param>
        /// <param name="project">The project in which the entity is defined.
        /// If this parameter is null, the project will be determined based on the file name.</param>
        /// <returns>The entity model if it could be found; or null otherwise.</returns>
        public static IEntityModel GetModel(this IUnresolvedEntity entity, IProject project = null)
        {
            if (project == null)
            {
                if (entity.Region.FileName == null)
                {
                    return(null);
                }
                project = SD.ProjectService.FindProjectContainingFile(FileName.Create(entity.Region.FileName));
                if (project == null)
                {
                    return(null);
                }
            }
            IUnresolvedTypeDefinition unresolvedTypeDefinition = entity as IUnresolvedTypeDefinition ?? entity.DeclaringTypeDefinition;

            if (unresolvedTypeDefinition == null)
            {
                return(null);
            }
            ITypeDefinitionModel typeModel = project.AssemblyModel.TopLevelTypeDefinitions[unresolvedTypeDefinition.FullTypeName];

            if (entity is IUnresolvedTypeDefinition || typeModel == null)
            {
                return(typeModel);
            }

            ITypeDefinition   typeDefinition   = typeModel.Resolve();
            IUnresolvedMember unresolvedMember = entity as IUnresolvedMember;

            if (typeDefinition == null || unresolvedMember == null)
            {
                return(null);
            }

            IMember member = unresolvedMember.Resolve(new SimpleTypeResolveContext(typeDefinition));

            if (member == null)
            {
                return(null);
            }
            var snapshot = member.Compilation.SolutionSnapshot as ISolutionSnapshotWithProjectMapping;

            foreach (var memberModel in typeModel.Members)
            {
                if (memberModel.Name == unresolvedMember.Name)
                {
                    if (memberModel.Resolve() == member.MemberDefinition)
                    {
                        return(memberModel);
                    }
                }
            }
            return(null);
        }
Esempio n. 20
0
        private IMember ConvertToMember(IUnresolvedMember input)
        {
            IUnresolvedField field = input as IUnresolvedField;

            if (field != null)
            {
                return(new VB6Field(field));
            }

            return(new VB6Member <IUnresolvedMember>(input));
        }
            public EventCompletionData(string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
            {
                SetDefaultText(varName);
                DeclarationCategory = DeclarationCategory.Event;
                // what should we do with parameterDefinition???
                DelegateType = delegateType;
                CurrentMember = currentMember;
                CurrentType = currentType;

                //Description = currentMember
            }
            public EventCompletionData(string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
            {
                SetDefaultText(varName);
                DeclarationCategory = DeclarationCategory.Event;
                // what should we do with parameterDefinition???
                DelegateType  = delegateType;
                CurrentMember = currentMember;
                CurrentType   = currentType;

                //Description = currentMember
            }
		public EventCreationCompletionData(string varName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret) : base(evt)
		{
			if (string.IsNullOrEmpty(varName)) {
				this.DisplayText = "Create handler for " + (evt != null ? evt.Name : "");
			}
			else {
				this.DisplayText = "Create handler for " + char.ToUpper(varName[0]) + varName.Substring(1) + (evt != null ? evt.Name : "");
			}
			
			this.DisplayText = "<" + this.DisplayText + ">";
			this.eventDefinition = evt;
			this.delegateType = delegateType;
		}
Esempio n. 24
0
			public IReadOnlyList<ITypeReference> GetLocalVariableTypes(IUnresolvedMember member)
			{
				rwLock.EnterReadLock();
				try {
					ITypeReference[] result;
					if (localVariableTypes.TryGetValue(member, out result))
						return result;
					else
						return EmptyList<ITypeReference>.Instance;
				} finally {
					rwLock.ExitReadLock();
				}
			}
Esempio n. 25
0
 public MemberModel(IEntityModelContext context, IUnresolvedMember member)
 {
     if (context == null)
     {
         throw new ArgumentNullException("context");
     }
     if (member == null)
     {
         throw new ArgumentNullException("member");
     }
     this.context = context;
     this.member  = member;
 }
Esempio n. 26
0
        /// <summary>
        ///   Initializes a new instance with no child nodes for the
        ///   given member.
        /// </summary>
        public Node(IUnresolvedMember member, IDocument document)
        {
            this.ChildNodes = null;
            this.Location   = QuickFix.ForNonBodyRegion(member, document);

            // Fields' BodyRegion does not include their name for some
            // reason. To prevent the field's name missing, include
            // the whole region for them.
            if (member.SymbolKind == SymbolKind.Field)
            {
                this.Location.Text += member.Name;
            }
        }
Esempio n. 27
0
        void membersComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            EntityItem item = membersComboBox.SelectedItem as EntityItem;

            if (item != null)
            {
                IUnresolvedMember member = item.Entity as IUnresolvedMember;
                if (member != null && jumpOnSelectionChange)
                {
                    SD.AnalyticsMonitor.TrackFeature(GetType(), "JumpToMember");
                    JumpTo(item, member.Region);
                }
            }
        }
Esempio n. 28
0
        public ICompletionData AddMember(IUnresolvedMember member)
        {
            var newData = Factory.CreateEntityCompletionData(member);

//				newData.HideExtensionParameter = HideExtensionParameter;
            string memberKey = newData.DisplayText;

            if (memberKey == null)
            {
                return(null);
            }
            if (member is IMember)
            {
                newData.CompletionCategory = GetCompletionCategory(member.DeclaringTypeDefinition.Resolve(completion.ctx));
            }
            List <ICompletionData> existingData;

            data.TryGetValue(memberKey, out existingData);

            if (existingData != null)
            {
                var a = member as IEntity;
                foreach (var d in existingData)
                {
                    if (!(d is IEntityCompletionData))
                    {
                        continue;
                    }
                    var b = ((IEntityCompletionData)d).Entity;
                    if (a == null || b == null || a.EntityType == b.EntityType)
                    {
                        d.AddOverload(newData);
                        return(d);
                    }
                }
                if (newData != null)
                {
                    result.Add(newData);
                    data [memberKey].Add(newData);
                }
            }
            else
            {
                result.Add(newData);
                data [memberKey] = new List <ICompletionData> ();
                data [memberKey].Add(newData);
            }
            return(newData);
        }
Esempio n. 29
0
        ResolveResult IParser.Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken)
        {
            VB6ParseInformation vpi     = (VB6ParseInformation)parseInfo;
            IUnresolvedMember   umember = vpi.UnresolvedFile.GetMember(location);

            if (umember != null)
            {
                IMember member = ConvertToMember(umember);
                if (member != null)
                {
                    return(new MemberResolveResult(null, member));
                }
            }

            return(null);
        }
            internal SearchResult CheckMember(ITypeDefinition declaringType, IUnresolvedMember member)
            {
                int    rank;
                bool   useDeclaringTypeName = member is IUnresolvedMethod && (((IUnresolvedMethod)member).IsConstructor || ((IUnresolvedMethod)member).IsDestructor);
                string memberName           = useDeclaringTypeName ? member.DeclaringTypeDefinition.Name : member.Name;

                if (MatchName(memberName, out rank))
                {
                    return new MemberSearchResult(pattern, memberName, rank, declaringType, member, false)
                           {
                               Ambience = ambience
                           }
                }
                ;
                return(null);
            }
 public IReadOnlyList <ITypeReference> GetLocalVariableTypes(IUnresolvedMember member)
 {
     rwLock.EnterReadLock();
     try {
         ITypeReference[] result;
         if (localVariableTypes.TryGetValue(member, out result))
         {
             return(result);
         }
         else
         {
             return(EmptyList <ITypeReference> .Instance);
         }
     } finally {
         rwLock.ExitReadLock();
     }
 }
        public override CodeGeneratorMemberResult CreateMemberImplementation(ITypeDefinition implementingType,
                                                                             IUnresolvedTypeDefinition part,
                                                                             IUnresolvedMember member,
                                                                             bool explicitDeclaration)
        {
            SetIndentTo(part);
            var options = new CodeGenerationOptions()
            {
                ExplicitDeclaration = explicitDeclaration,
                ImplementingType    = implementingType,
                Part = part
            };
            ITypeResolveContext ctx;

            var doc = IdeApp.Workbench.GetDocument(part.Region.FileName);

            if (doc != null)
            {
                ctx = doc.ParsedDocument.GetTypeResolveContext(doc.Compilation, implementingType.Region.Begin);
            }
            else
            {
                ctx = new CSharpTypeResolveContext(implementingType.Compilation.MainAssembly, null, implementingType, null);
            }
            options.Document = doc;

            if (member is IUnresolvedMethod)
            {
                return(GenerateCode((IMethod)((IUnresolvedMethod)member).CreateResolved(ctx), options));
            }
            if (member is IUnresolvedProperty)
            {
                return(GenerateCode((IProperty)((IUnresolvedProperty)member).CreateResolved(ctx), options));
            }
            if (member is IUnresolvedField)
            {
                return(GenerateCode((IField)((IUnresolvedField)member).CreateResolved(ctx), options));
            }
            if (member is IUnresolvedEvent)
            {
                return(GenerateCode((IEvent)((IUnresolvedEvent)member).CreateResolved(ctx), options));
            }
            throw new NotSupportedException("member " + member + " is not supported.");
        }
Esempio n. 33
0
        protected void SetOffset(int offset)
        {
            Reset();

            this.offset   = offset;
            this.location = document.GetLocation(offset);

            this.currentType = null;

            foreach (var type in CSharpParsedFile.TopLevelTypeDefinitions)
            {
                if (type.Region.Begin < location)
                {
                    currentType = type;
                }
            }
            currentType = FindInnerType(currentType, location);

            // location is beyond last reported end region, now we need to check, if the end region changed
            if (currentType != null && currentType.Region.End < location)
            {
                if (!IsInsideType(currentType, location))
                {
                    currentType = null;
                }
            }
            this.currentMember = null;
            if (this.currentType != null)
            {
                foreach (var member in currentType.Members)
                {
                    if (member.Region.Begin < location && (currentMember == null || currentMember.Region.Begin < member.Region.Begin))
                    {
                        currentMember = member;
                    }
                }
            }
            var stack = GetBracketStack(GetMemberTextToCaret().Item1);

            if (stack.Count == 0)
            {
                currentMember = null;
            }
        }
        public EventCreationCompletionData(string varName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType, CSharpResolver contextAtCaret)
        {
            if (string.IsNullOrEmpty(varName))
            {
                this.DisplayText = "<Create handler for " + (evt != null ? evt.Name : "") + ">";
            }
            else
            {
                this.DisplayText = "Handle" + char.ToUpper(varName[0]) + varName.Substring(1) + (evt != null ? evt.Name : "");
            }

            this.varName         = varName;
            this.eventDefinition = evt;
            this.delegateType    = delegateType;
            this.parameterList   = parameterList;
            this.callingMember   = callingMember;
            this.declaringType   = declaringType;
            this.contextAtCaret  = contextAtCaret;
        }
Esempio n. 35
0
		protected void SetOffset (int offset)
		{
			Reset ();
			
			this.offset = offset;
			this.location = document.GetLocation (offset);
			
			this.currentType = CSharpParsedFile.GetInnermostTypeDefinition (location);
			this.currentMember = null;
			if (this.currentType != null) {
				foreach (var member in currentType.Members) {
					if (member.Region.Begin < location && (currentMember == null || currentMember.Region.Begin < member.Region.Begin))
						currentMember = member;
				}
			}
			var stack = GetBracketStack (GetMemberTextToCaret ().Item1);
			if (stack.Count == 0)
				currentMember = null;
		}
		bool CanMatch(IUnresolvedMember member)
		{
			switch (member.SymbolKind) {
				case SymbolKind.Field:
					return memberType == 'F';
				case SymbolKind.Property:
				case SymbolKind.Indexer:
					return memberType == 'P';
				case SymbolKind.Event:
					return memberType == 'E';
				case SymbolKind.Method:
				case SymbolKind.Operator:
				case SymbolKind.Constructor:
				case SymbolKind.Destructor:
					return memberType == 'M';
				default:
					throw new NotSupportedException(member.SymbolKind.ToString());
			}
		}
		bool CanMatch(IUnresolvedMember member)
		{
			switch (member.EntityType) {
				case EntityType.Field:
					return memberType == 'F';
				case EntityType.Property:
				case EntityType.Indexer:
					return memberType == 'P';
				case EntityType.Event:
					return memberType == 'E';
				case EntityType.Method:
				case EntityType.Operator:
				case EntityType.Constructor:
				case EntityType.Destructor:
					return memberType == 'M';
				default:
					throw new NotSupportedException(member.EntityType.ToString());
			}
		}
        public static void AddNewMembers(Project project, ITypeDefinition type, IUnresolvedTypeDefinition part, IEnumerable <IUnresolvedMember> newMembers, string regionName = null, Func <IUnresolvedMember, bool> implementExplicit = null)
        {
            IUnresolvedMember firstNewMember = newMembers.FirstOrDefault();

            if (firstNewMember == null)
            {
                return;
            }
            bool isOpen;
            var  data           = TextFileProvider.Instance.GetTextEditorData(part.Region.FileName, out isOpen);
            var  parsedDocument = TypeSystemService.ParseFile(project, data);

            var insertionPoints = GetInsertionPoints(data, parsedDocument, part);


            var suitableInsertionPoint = GetSuitableInsertionPoint(insertionPoints, part, firstNewMember);

            var generator = CreateCodeGenerator(data, type.Compilation);

            generator.IndentLevel = CalculateBodyIndentLevel(parsedDocument.GetInnermostTypeDefinition(part.Region.Begin));
            StringBuilder sb = new StringBuilder();

            foreach (var newMember in newMembers)
            {
                if (sb.Length > 0)
                {
                    sb.AppendLine();
                    sb.AppendLine();
                }
                sb.Append(generator.CreateMemberImplementation(type, part, newMember, implementExplicit != null ? implementExplicit(newMember) : false).Code);
            }
            suitableInsertionPoint.Insert(data, string.IsNullOrEmpty(regionName) ? sb.ToString() : generator.WrapInRegions(regionName, sb.ToString()));
            if (!isOpen)
            {
                try {
                    File.WriteAllText(type.Region.FileName, data.Text);
                } catch (Exception e) {
                    LoggingService.LogError(GettextCatalog.GetString("Failed to write file '{0}'.", type.Region.FileName), e);
                    MessageService.ShowError(GettextCatalog.GetString("Failed to write file '{0}'.", type.Region.FileName));
                }
            }
        }
        public static Task <bool> InsertMember(
            ITypeDefinition parentType, IUnresolvedTypeDefinition part,
            IUnresolvedMember newMember, bool implementExplicit = false)
        {
            var tcs = new TaskCompletionSource <bool>();

            if (parentType == null)
            {
                return(tcs.Task);
            }
            part = part ?? FindCurrentPart(parentType);
            if (part == null)
            {
                return(tcs.Task);
            }

            var loadedDocument = IdeApp.Workbench.OpenDocument(part.Region.FileName);

            loadedDocument.RunWhenLoaded(delegate {
                var editor          = loadedDocument.Editor;
                var loc             = part.Region.Begin;
                var parsedDocument  = loadedDocument.UpdateParseDocument();
                var declaringType   = parsedDocument.GetInnermostTypeDefinition(loc);
                var insertionPoints = CodeGenerationService.GetInsertionPoints(loadedDocument, declaringType);
                if (insertionPoints.Count == 0)
                {
                    MessageService.ShowError(
                        GettextCatalog.GetString("No valid insertion point can be found in type '{0}'.", declaringType.Name)
                        );
                    return;
                }
                var suitableInsertionPoint = GetSuitableInsertionPoint(insertionPoints, part, newMember) ?? insertionPoints.First();

                var generator         = CreateCodeGenerator(editor, parentType.Compilation);
                generator.IndentLevel = CalculateBodyIndentLevel(declaringType);
                var generatedCode     = generator.CreateMemberImplementation(parentType, part, newMember, implementExplicit);
                suitableInsertionPoint.Insert(editor, generatedCode.Code);
            });

            return(tcs.Task);
        }
		public EventCreationCompletionData (CSharpCompletionTextEditorExtension ext, string varName, IType delegateType, IEvent evt, string parameterList, IUnresolvedMember callingMember, IUnresolvedTypeDefinition declaringType) : base (null)
		{
			if (string.IsNullOrEmpty (varName)) {
				this.DisplayText   = "Handle" + (evt != null ? evt.Name : "");
			} else {
				this.DisplayText   = "Handle" + Char.ToUpper (varName[0]) + varName.Substring (1) + (evt != null ? evt.Name : "");
			}
			
			if (declaringType != null && declaringType.Members.Any (m => m.Name == this.DisplayText)) {
				for (int i = 1; i < 10000; i++) {
					if (!declaringType.Members.Any (m => m.Name == this.DisplayText + i)) {
						this.DisplayText = this.DisplayText + i.ToString ();
						break;
					}
				}
			}
			this.editor        = ext.TextEditorData;
			this.parameterList = parameterList;
			this.callingMember = callingMember;
			this.Icon          = "md-newmethod";
			this.initialOffset = editor.Caret.Offset;
		}
Esempio n. 41
0
        IEnumerable <IMethod> GetFilteredAccessors(Predicate <IUnresolvedMethod> filter)
        {
            var members = GetMemberList();

            for (int i = 0; i < members.unresolvedMembers.Length; i++)
            {
                IUnresolvedMember unresolved = members.unresolvedMembers[i];
                var unresolvedProperty       = unresolved as IUnresolvedProperty;
                var unresolvedEvent          = unresolved as IUnresolvedEvent;
                if (unresolvedProperty != null)
                {
                    if (unresolvedProperty.CanGet && (filter == null || filter(unresolvedProperty.Getter)))
                    {
                        yield return(((IProperty)members[i]).Getter);
                    }
                    if (unresolvedProperty.CanSet && (filter == null || filter(unresolvedProperty.Setter)))
                    {
                        yield return(((IProperty)members[i]).Setter);
                    }
                }
                else if (unresolvedEvent != null)
                {
                    if (unresolvedEvent.CanAdd && (filter == null || filter(unresolvedEvent.AddAccessor)))
                    {
                        yield return(((IEvent)members[i]).AddAccessor);
                    }
                    if (unresolvedEvent.CanRemove && (filter == null || filter(unresolvedEvent.RemoveAccessor)))
                    {
                        yield return(((IEvent)members[i]).RemoveAccessor);
                    }
                    if (unresolvedEvent.CanInvoke && (filter == null || filter(unresolvedEvent.InvokeAccessor)))
                    {
                        yield return(((IEvent)members[i]).InvokeAccessor);
                    }
                }
            }
        }
        bool CanMatch(IUnresolvedMember member)
        {
            switch (member.EntityType)
            {
            case EntityType.Field:
                return(memberType == 'F');

            case EntityType.Property:
            case EntityType.Indexer:
                return(memberType == 'P');

            case EntityType.Event:
                return(memberType == 'E');

            case EntityType.Method:
            case EntityType.Operator:
            case EntityType.Constructor:
            case EntityType.Destructor:
                return(memberType == 'M');

            default:
                throw new NotSupportedException(member.EntityType.ToString());
            }
        }
		public void GetCurrentMembers(int offset, out IUnresolvedTypeDefinition currentType, out IUnresolvedMember currentMember)
		{
			//var document = engine.document;
			var location = document.GetLocation(offset);
			
			currentType = null;
			
			foreach (var type in unresolvedFile.TopLevelTypeDefinitions) {
				if (type.Region.Begin < location)
					currentType = type;
			}
			currentType = FindInnerType (currentType, location);
			
			// location is beyond last reported end region, now we need to check, if the end region changed
			if (currentType != null && currentType.Region.End < location) {
				if (!IsInsideType (currentType, location))
					currentType = null;
			}
			currentMember = null;
			if (currentType != null) {
				foreach (var member in currentType.Members) {
					if (member.Region.Begin < location && (currentMember == null || currentMember.Region.Begin < member.Region.Begin))
						currentMember = member;
				}
			}
			
			// location is beyond last reported end region, now we need to check, if the end region changed
			// NOTE: Enums are a special case, there the "last" field needs to be treated as current member
			if (currentMember != null && currentMember.Region.End < location && currentType.Kind != TypeKind.Enum) {
				if (!IsInsideType (currentMember, location))
					currentMember = null;
			}/*
			var stack = GetBracketStack (engine.GetMemberTextToCaret ().Item1);
			if (stack.Count == 0)
				currentMember = null;*/
		}
Esempio n. 44
0
        bool CanMatch(IUnresolvedMember member)
        {
            switch (member.SymbolKind)
            {
            case SymbolKind.Field:
                return(memberType == 'F');

            case SymbolKind.Property:
            case SymbolKind.Indexer:
                return(memberType == 'P');

            case SymbolKind.Event:
                return(memberType == 'E');

            case SymbolKind.Method:
            case SymbolKind.Operator:
            case SymbolKind.Constructor:
            case SymbolKind.Destructor:
                return(memberType == 'M');

            default:
                throw new NotSupportedException(member.SymbolKind.ToString());
            }
        }
Esempio n. 45
0
		public static void AddNewMember (ITypeDefinition type, IUnresolvedTypeDefinition part, IUnresolvedMember newMember, bool implementExplicit = false)
		{
			bool isOpen;
			var data = TextFileProvider.Instance.GetTextEditorData (part.Region.FileName, out isOpen);
			var parsedDocument = TypeSystemService.ParseFile (data.FileName, data.MimeType, data.Text);
			
			var insertionPoints = GetInsertionPoints (data, parsedDocument, part);
			
			var suitableInsertionPoint = GetSuitableInsertionPoint (insertionPoints, part, newMember);
			
			var generator = CreateCodeGenerator (data, type.Compilation);

			generator.IndentLevel = CalculateBodyIndentLevel (parsedDocument.GetInnermostTypeDefinition (type.Region.Begin));
			var generatedCode = generator.CreateMemberImplementation (type, part, newMember, implementExplicit);
			suitableInsertionPoint.Insert (data, generatedCode.Code);
			if (!isOpen) {
				try {
					File.WriteAllText (type.Region.FileName, data.Text);
				} catch (Exception e) {
					LoggingService.LogError (GettextCatalog.GetString ("Failed to write file '{0}'.", type.Region.FileName), e);
					MessageService.ShowError (GettextCatalog.GetString ("Failed to write file '{0}'.", type.Region.FileName));
				}
			}
		}
		ICompletionData ICompletionDataFactory.CreateNewPartialCompletionData(int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember m)
		{
			return new CompletionData("TODO: partial completion");
		}
 public ICompletionData CreateNewPartialCompletionData(int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember m)
 {
     throw new NotImplementedException();
 }
Esempio n. 48
0
 protected AbstractResolvedMember(IUnresolvedMember unresolved, ITypeResolveContext parentContext)
     : base(unresolved, parentContext)
 {
     this.unresolved = unresolved;
     this.context    = parentContext.WithCurrentMember(this);
 }
		public override CodeGeneratorMemberResult CreateMemberImplementation (ITypeDefinition implementingType,
		                                                                      IUnresolvedTypeDefinition part,
		                                                                      IUnresolvedMember member,
		                                                                      bool explicitDeclaration)
		{
			SetIndentTo (part);
			var options = new CodeGenerationOptions () {
				ExplicitDeclaration = explicitDeclaration,
				ImplementingType = implementingType,
				Part = part
			};
			ITypeResolveContext ctx;

			var doc = IdeApp.Workbench.GetDocument (part.Region.FileName);
			ctx = new CSharpTypeResolveContext (implementingType.Compilation.MainAssembly, null, implementingType, null);
			options.Document = doc;

			if (member is IUnresolvedMethod)
				return GenerateCode ((IMethod) ((IUnresolvedMethod)member).CreateResolved (ctx), options);
			if (member is IUnresolvedProperty)
				return GenerateCode ((IProperty) ((IUnresolvedProperty)member).CreateResolved (ctx), options);
			if (member is IUnresolvedField)
				return GenerateCode ((IField) ((IUnresolvedField)member).CreateResolved (ctx), options);
			if (member is IUnresolvedEvent)
				return GenerateCode ((IEvent) ((IUnresolvedEvent)member).CreateResolved (ctx), options);
			throw new NotSupportedException ("member " +  member + " is not supported.");
		}
Esempio n. 50
0
			public ICompletionData CreateNewPartialCompletionData (int declarationBegin, IUnresolvedTypeDefinition type, IUnresolvedMember m)
			{
				return new CompletionData (m.Name);
			}
Esempio n. 51
0
		static InsertionPoint GetSuitableInsertionPoint (IEnumerable<InsertionPoint> points, IUnresolvedTypeDefinition cls, IUnresolvedMember member)
		{
			var mainPart = cls;
			switch (member.EntityType) {
			case EntityType.Field:
				return GetNewFieldPosition (points, mainPart);
			case EntityType.Method:
			case EntityType.Constructor:
			case EntityType.Destructor:
			case EntityType.Operator:
				return GetNewMethodPosition (points, mainPart);
			case EntityType.Event:
				return GetNewEventPosition (points, mainPart);
			case EntityType.Property:
				return GetNewPropertyPosition (points, mainPart);
			}
			throw new InvalidOperationException ("Invalid member type: " + member.EntityType);
		}
		public static Task<bool> InsertMember (
			ITypeDefinition parentType, IUnresolvedTypeDefinition part,
			IUnresolvedMember newMember, bool implementExplicit = false)
		{
			var tcs = new TaskCompletionSource<bool>();
			if (parentType == null)
				return tcs.Task;
			part = part ?? parentType.Parts.FirstOrDefault ();
			if (part == null)
				return tcs.Task;

			var loadedDocument = IdeApp.Workbench.OpenDocument (part.Region.FileName);
			loadedDocument.RunWhenLoaded (delegate {
				var editor = loadedDocument.Editor;
				var loc = part.Region.Begin;
				var parsedDocument = loadedDocument.UpdateParseDocument ();
				var declaringType = parsedDocument.GetInnermostTypeDefinition (loc);
				var insertionPoints = CodeGenerationService.GetInsertionPoints (loadedDocument, declaringType);
				if (insertionPoints.Count == 0) {
					MessageService.ShowError (
						GettextCatalog.GetString ("No valid insertion point can be found in type '{0}'.", declaringType.Name)
						);
					return;
				}
				var suitableInsertionPoint = GetSuitableInsertionPoint (insertionPoints, part, newMember) ?? insertionPoints.First ();

				var generator = CreateCodeGenerator (editor, parentType.Compilation);
				generator.IndentLevel = CalculateBodyIndentLevel (declaringType);
				var generatedCode = generator.CreateMemberImplementation (parentType, part, newMember, implementExplicit);
				suitableInsertionPoint.Insert (editor, generatedCode.Code);
			});

			return tcs.Task;
		}
		public static Task<bool> InsertMemberWithCursor (
			string operation, ITypeDefinition parentType, IUnresolvedTypeDefinition part,
			IUnresolvedMember newMember, bool implementExplicit = false)
		{
			var tcs = new TaskCompletionSource<bool>();
			if (parentType == null)
				return tcs.Task;
			part = part ?? parentType.Parts.FirstOrDefault ();
			if (part == null)
				return tcs.Task;
			var loadedDocument = IdeApp.Workbench.OpenDocument (part.Region.FileName);
			loadedDocument.RunWhenLoaded (delegate {
				var editor = loadedDocument.Editor;
				var loc = part.Region.Begin;
				var parsedDocument = loadedDocument.UpdateParseDocument ();
				var declaringType = parsedDocument.GetInnermostTypeDefinition (loc);
				var mode = new InsertionCursorEditMode (
					editor.Parent,
					CodeGenerationService.GetInsertionPoints (loadedDocument, declaringType));
				if (mode.InsertionPoints.Count == 0) {
					MessageService.ShowError (
						GettextCatalog.GetString ("No valid insertion point can be found in type '{0}'.", declaringType.Name)
						);
					return;
				}
				var suitableInsertionPoint = GetSuitableInsertionPoint (mode.InsertionPoints, part, newMember);
				if (suitableInsertionPoint != null)
					mode.CurIndex = mode.InsertionPoints.IndexOf (suitableInsertionPoint);
				else
					mode.CurIndex = 0;

				var helpWindow = new Mono.TextEditor.PopupWindow.InsertionCursorLayoutModeHelpWindow () {
					TitleText = operation
				};
				mode.HelpWindow = helpWindow;

				mode.StartMode ();
				mode.Exited += delegate(object s, InsertionCursorEventArgs iCArgs) {
					if (!iCArgs.Success) {
						tcs.SetResult (false);
						return;
					}
					var generator = CreateCodeGenerator (editor, parentType.Compilation);
					generator.IndentLevel = CalculateBodyIndentLevel (declaringType);
					var generatedCode = generator.CreateMemberImplementation (parentType, part, newMember, implementExplicit);
					mode.InsertionPoints[mode.CurIndex].Insert (editor, generatedCode.Code);
					tcs.SetResult (true);
				};
			});

			return tcs.Task;
		}
Esempio n. 54
0
		public override CodeGeneratorMemberResult CreateMemberImplementation (ITypeDefinition implementingType,
		                                                                      IUnresolvedTypeDefinition part,
		                                                                      IUnresolvedMember member,
		                                                                      bool explicitDeclaration)
		{
			SetIndentTo (part);
			var options = new CodeGenerationOptions () {
				ExplicitDeclaration = explicitDeclaration,
				ImplementingType = implementingType,
				Part = part
			};
			if (member is IMethod)
				return GenerateCode ((IMethod)member, options);
			if (member is IProperty)
				return GenerateCode ((IProperty)member, options);
			if (member is IField)
				return GenerateCode ((IField)member, options);
			if (member is IEvent)
				return GenerateCode ((IEvent)member, options);
			throw new NotSupportedException ("member " +  member + " is not supported.");
		}
Esempio n. 55
0
		protected AbstractResolvedMember(IUnresolvedMember unresolved, ITypeResolveContext parentContext)
			: base(unresolved, parentContext)
		{
			this.unresolved = unresolved;
			this.context = parentContext.WithCurrentMember(this);
		}
 ICompletionData ICompletionDataFactory.CreateEventCreationCompletionData(string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
 {
     return new CompletionData("TODO: event creation");
 }
Esempio n. 57
0
		public ICompletionData AddMember (IUnresolvedMember member)
		{
			var newData = Factory.CreateEntityCompletionData (member);
			
//				newData.HideExtensionParameter = HideExtensionParameter;
			string memberKey = newData.DisplayText;
			if (memberKey == null)
				return null;
			if (member is IMember) {
				newData.CompletionCategory = GetCompletionCategory (member.DeclaringTypeDefinition.Resolve (completion.ctx));
			}
			List<ICompletionData> existingData;
			data.TryGetValue (memberKey, out existingData);
				
			if (existingData != null) {
				var a = member as IEntity;
				foreach (var d in existingData) {
					if (!(d is IEntityCompletionData))
						continue;
					var b = ((IEntityCompletionData)d).Entity;
					if (a == null || b == null || a.EntityType == b.EntityType) {
						d.AddOverload (newData);
						return d;
					} 
				}
				if (newData != null) {
					result.Add (newData);
					data [memberKey].Add (newData);
				}
			} else {
				result.Add (newData);
				data [memberKey] = new List<ICompletionData> ();
				data [memberKey].Add (newData);
			}
			return newData;
		}
		ICompletionData ICompletionDataFactory.CreateEventCreationCompletionData(string varName, IType delegateType, IEvent evt, string parameterDefinition, IUnresolvedMember currentMember, IUnresolvedTypeDefinition currentType)
		{
			return new EventCreationCompletionData(varName, delegateType, evt, parameterDefinition, currentMember, currentType, contextAtCaret);
		}
		public MemberSearchResult (string match, string matchedString, int rank, ITypeDefinition declaringType, IUnresolvedMember member, bool useFullName) : base (match, matchedString, rank)
		{
			this.declaringType = declaringType;
			this.member = member;
			this.useFullName = useFullName;
		}
Esempio n. 60
0
 public IMemberModel CreateMemberModel(IEntityModelContext context, IUnresolvedMember member)
 {
     return new MemberModel(context, member);
 }