public void Initialize(IClass currentClass)
		{
			this.currentClass = currentClass.GetCompoundClass();
			this.codeGen = currentClass.ProjectContent.Language.CodeGenerator;
			this.classFinderContext = new ClassFinder(currentClass, currentClass.Region.BeginLine + 1, 0);
			this.InitContent();
		}
		/// <summary>
		/// Called when this switch body element is inserted to the editor.
		/// </summary>
		public override void Insert(InsertionContext context)
		{
			this.context = context;
			this.context.Deactivated += new EventHandler<SnippetEventArgs>(InteractiveModeCompleted);
			this.anchor = SetUpAnchorAtInsertion(context);
			this.classFinderContext = new ClassFinder(ParserService.ParseCurrentViewContent(), Editor.Document.Text, Editor.Caret.Offset);
		}
        Variable ResolveVariable(Variable variable)
        {
            Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName);
            Dom.ExpressionResult res  = new Dom.ExpressionResult(variable.Name,
                                                                 Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos),
                                                                 Dom.ExpressionContext.Default, null);
            Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.Text);

            Dom.IReturnType type   = currentProjectContent.SystemTypes.Object;
            Dom.ClassFinder finder = new Dom.ClassFinder(currentClass, textEditor.Caret.Line, textEditor.Caret.Column);

            if (result != null && result.ResolvedType != null)
            {
                type = result.ResolvedType;
            }

            if (variable.Type.Type == "var")
            {
                variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(type, finder);
            }

            variable.IsReferenceType = type.IsReferenceType == true;

            return(variable);
        }
		public void Insert(CompletionContext context, ICompletionItem item)
		{
			if (item == null)
				throw new ArgumentNullException("item");
			
			if (!(item is OverrideCompletionItem))
				throw new ArgumentException("item is not an OverrideCompletionItem");
			
			OverrideCompletionItem completionItem = item as OverrideCompletionItem;
			
			ITextEditor textEditor = context.Editor;
			
			IEditorUIService uiService = textEditor.GetService(typeof(IEditorUIService)) as IEditorUIService;
			
			if (uiService == null)
				return;
			
			ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName);
			
			if (parseInfo == null)
				return;
			
			CodeGenerator generator = parseInfo.CompilationUnit.Language.CodeGenerator;
			IClass current = parseInfo.CompilationUnit.GetInnermostClass(textEditor.Caret.Line, textEditor.Caret.Column);
			ClassFinder finder = new ClassFinder(current, textEditor.Caret.Line, textEditor.Caret.Column);
			
			if (current == null)
				return;
			
			using (textEditor.Document.OpenUndoGroup()) {
				ITextAnchor startAnchor = textEditor.Document.CreateAnchor(textEditor.Caret.Offset);
				startAnchor.MovementType = AnchorMovementType.BeforeInsertion;
				
				ITextAnchor endAnchor = textEditor.Document.CreateAnchor(textEditor.Caret.Offset);
				endAnchor.MovementType = AnchorMovementType.AfterInsertion;
				
				MethodDeclaration member = (MethodDeclaration)generator.GetOverridingMethod(completionItem.Member, finder);
				
				string indent = DocumentUtilitites.GetWhitespaceBefore(textEditor.Document, textEditor.Caret.Offset);
				string codeForBaseCall = generator.GenerateCode(member.Body.Children.OfType<AbstractNode>().First(), "");
				string code = generator.GenerateCode(member, indent);
				int marker = code.IndexOf(codeForBaseCall);
				
				textEditor.Document.Insert(startAnchor.Offset, code.Substring(0, marker).TrimStart());
				
				ITextAnchor insertionPos = textEditor.Document.CreateAnchor(endAnchor.Offset);
				insertionPos.MovementType = AnchorMovementType.BeforeInsertion;
				
				InsertionContext insertionContext = new InsertionContext(textEditor.GetService(typeof(TextArea)) as TextArea, startAnchor.Offset);
				
				AbstractInlineRefactorDialog dialog = new OverrideEqualsGetHashCodeMethodsDialog(insertionContext, textEditor, startAnchor, endAnchor, insertionPos, current, completionItem.Member as IMethod, codeForBaseCall.Trim());
				dialog.Element = uiService.CreateInlineUIElement(insertionPos, dialog);
				
				textEditor.Document.InsertNormalized(endAnchor.Offset, Environment.NewLine + code.Substring(marker + codeForBaseCall.Length));
				
				insertionContext.RegisterActiveElement(new InlineRefactorSnippetElement(cxt => null, ""), dialog);
				insertionContext.RaiseInsertionCompleted(EventArgs.Empty);
			}
		}
		public AttributeReturnType(ClassFinder context, string name)
		{
			if (context == null)
				throw new ArgumentNullException("context");
			if (name == null)
				throw new ArgumentNullException("name");
			this.name = name;
			scrt1 = new SearchClassReturnType(context.ProjectContent, context.CallingClass,
			                                  context.CaretLine, context.CaretColumn, name, 0);
			scrt2 = new SearchClassReturnType(context.ProjectContent, context.CallingClass,
			                                  context.CaretLine, context.CaretColumn, name + "Attribute", 0);
		}
		protected AbstractInlineRefactorDialog(InsertionContext context, ITextEditor editor, ITextAnchor anchor)
		{
			if (context == null)
				throw new ArgumentNullException("context");
			
			this.anchor = insertionEndAnchor = anchor;
			this.editor = editor;
			this.context = context;
			
			this.classFinderContext = new ClassFinder(ParserService.ParseCurrentViewContent(), editor.Document.Text, anchor.Offset);
			
			this.Background = SystemColors.ControlBrush;
		}
        public static PropertyDeclaration add_Property(this TypeDeclaration typeDeclaration, IProperty iProperty)
        {
            foreach (var child in typeDeclaration.Children)
                if (child is PropertyDeclaration)
                    if ((child as PropertyDeclaration).Name == iProperty.Name)
                        return (child as PropertyDeclaration);
            //if (field != null)
            //    return field;
            AttributedNode property = null;
            var classFinder = new ClassFinder(iProperty.DeclaringType, 0, 0);

            property = ICSharpCode.SharpDevelop.Dom.Refactoring.CodeGenerator.ConvertMember(iProperty, classFinder);
            if (property != null && property is PropertyDeclaration)
                return typeDeclaration.add_Property(property as  PropertyDeclaration);
                //typeDeclaration.Children.Insert(0, property);
            if (property is PropertyDeclaration)
                return (PropertyDeclaration)property;

            "in add_Property could not convert property into PropertyDeclaration, because it is: {0}".error(property.typeName());
            return null;
        }
Example #8
0
		public void Complete(CompletionContext context)
		{
			ITextEditor editor = context.Editor;
			ClassFinder classFinder = new ClassFinder(ParserService.GetParseInformation(editor.FileName),
			                                          editor.Caret.Line, editor.Caret.Column);
			int caretPosition = editor.Caret.Offset;
			IDocumentLine line = editor.Document.GetLine(editor.Caret.Line);
			string lineText = editor.Document.GetText(line.Offset, caretPosition - line.Offset);
			foreach (char c in lineText) {
				if (!char.IsWhiteSpace(c) && !char.IsLetterOrDigit(c)) {
					editor.Document.Replace(context.StartOffset, context.Length, this.Text);
					context.EndOffset = context.StartOffset + this.Text.Length;
					return;
				}
			}
			
			string indentation = lineText.Substring(0, lineText.Length - lineText.TrimStart().Length);

			editor.Document.Remove(line.Offset, caretPosition - line.Offset);
			
			foreach (ICompletionItemHandler handler in handlers) {
				if (handler.Handles(this)) {
					editor.Document.Insert(line.Offset, indentation);
					handler.Insert(context, this);
					return;
				}
			}
			
			CodeGenerator codeGen = ParserService.CurrentProjectContent.Language.CodeGenerator;
			
			string text = codeGen.GenerateCode(codeGen.GetOverridingMethod(member, classFinder), indentation);
			text = text.TrimEnd(); // remove newline from end
			
			editor.Document.Insert(line.Offset, text);
			
			int endPos = line.Offset + text.Length;
			line = editor.Document.GetLineForOffset(endPos);
			editor.JumpTo(line.LineNumber, endPos - line.Offset + 1);
		}
        public static FieldDeclaration add_Field(this TypeDeclaration typeDeclaration, IField iField)
        {
            // move to fields(..) extensionmethods
            FieldDeclaration field = null;
            foreach(var child in typeDeclaration.Children)
                if (child is FieldDeclaration)
                    foreach (var variable in (child as FieldDeclaration).Fields)
                    {
                        if (variable.Name == iField.Name)
                            field = (child as FieldDeclaration);
                    }
            if (field != null)
                return field;

            var classFinder = new ClassFinder(iField.DeclaringType, 0,0);
            field = ICSharpCode.SharpDevelop.Dom.Refactoring.CodeGenerator.ConvertMember(iField, classFinder);

            typeDeclaration.add_Field(field);
            //var varia = new
            //var field = new FieldDeclaration(
            /*var fields = (from child in typeDeclaration.Children
                         where child is FieldDeclaration
                         select (FieldDeclaration)child).ToList();
            */
            //var fields = typeDeclaration.fields

            /*var newType = namespaceDeclaration.types(typeName);		// check if already exists and if it does return it
            if (newType != null)
                return newType;

            const Modifiers modifiers = Modifiers.None | Modifiers.Public;
            newType = new TypeDeclaration(modifiers, new List<AttributeSection>())
            {
                Name = typeName
            };
            namespaceDeclaration.AddChild(newType);*/
            return field;
        }
Example #10
0
		IEnumerable<Ast.ParameterDeclarationExpression> CreateParameters(UnknownMethodResolveResult rr, ClassFinder context, Ast.InvocationExpression invocation)
		{
			List<string> usedNames = new List<string>();
			
			for (int i = 0; i < rr.Arguments.Count; i++) {
				IReturnType type = rr.Arguments[i];
				
				if (type is LambdaReturnType)
					type = (type as LambdaReturnType).ToDefaultDelegate();
				
				Ast.TypeReference typeRef = CodeGenerator.ConvertType(type, context);
				typeRef = typeRef.IsNull ? new Ast.TypeReference("object", true) : typeRef;
				
				Ast.Expression ex = invocation.Arguments[i];
				string paramName = IsNumericType(type) ? "num" + i : type.Name + i.ToString();
				
				if (ex is Ast.IdentifierExpression) {
					paramName = (ex as Ast.IdentifierExpression).Identifier;
				}
				
				if (ex is Ast.MemberReferenceExpression) {
					paramName = (ex as Ast.MemberReferenceExpression).MemberName;
				}
				
				Ast.ParameterModifiers mod = Ast.ParameterModifiers.None;
				
				if (ex is Ast.DirectionExpression) {
					var dex = ex as Ast.DirectionExpression;
					
					if (dex.Expression is Ast.IdentifierExpression) {
						paramName = (dex.Expression as Ast.IdentifierExpression).Identifier;
					}
					
					if (dex.Expression is Ast.MemberReferenceExpression) {
						paramName = (dex.Expression as Ast.MemberReferenceExpression).MemberName;
					}
					
					mod = dex.FieldDirection == Ast.FieldDirection.Out ? Ast.ParameterModifiers.Out : (dex.FieldDirection == Ast.FieldDirection.Ref ? Ast.ParameterModifiers.Ref : Ast.ParameterModifiers.None);
				}
				
				paramName = rr.CallingClass.ProjectContent.Language.CodeGenerator.GetParameterName(paramName);
				
				if (usedNames.Contains(paramName))
					paramName += i.ToString();
				
				usedNames.Add(paramName);
				
				yield return new Ast.ParameterDeclarationExpression(typeRef, paramName) {
					ParamModifier = mod
				};
			}
		}
Example #11
0
		internal void ExecuteIntroduceMethod(UnknownMethodResolveResult rr, Ast.Expression invocationExpr, ITextEditor editor, bool isNew, object result)
		{
			IClass targetClass = IsEqualClass(rr.CallingClass, rr.Target.GetUnderlyingClass()) ? rr.CallingClass
				: rr.Target.GetUnderlyingClass();
			
			CodeGenerator gen = targetClass.ProjectContent.Language.CodeGenerator;
			IAmbience ambience = targetClass.ProjectContent.Language.GetAmbience();
			
			ClassFinder finder = new ClassFinder(rr.CallingMember);
			
			ModifierEnum modifiers = ModifierEnum.None;
			
			bool isExtension = !targetClass.IsUserCode();
			
			if (IsEqualClass(rr.CallingClass, targetClass)) {
				if (rr.CallingMember != null)
					modifiers |= (rr.CallingMember.Modifiers & ModifierEnum.Static);
			} else {
				if (isExtension) {
					if (isNew)
						targetClass = rr.CallingClass;
					else
						targetClass = result as IClass;
				}
				// exclude in Unit Test mode
				if (WorkbenchSingleton.Workbench != null)
					editor = (FileService.OpenFile(targetClass.CompilationUnit.FileName) as ITextEditorProvider).TextEditor;
				if (targetClass.ClassType != ClassType.Interface)
					modifiers |= ModifierEnum.Public;
				if (rr.IsStaticContext)
					modifiers |= ModifierEnum.Static;
			}
			
			NRefactoryResolver resolver = Extensions.CreateResolverForContext(targetClass.ProjectContent.Language, editor);
			
			IReturnType type = resolver.GetExpectedTypeFromContext(invocationExpr);
			Ast.TypeReference typeRef = CodeGenerator.ConvertType(type, finder);
			
			if (typeRef.IsNull) {
				if (invocationExpr.Parent is Ast.ExpressionStatement)
					typeRef = new Ast.TypeReference("void", true);
				else
					typeRef = new Ast.TypeReference("object", true);
			}
			
			Ast.MethodDeclaration method = new Ast.MethodDeclaration {
				Name = rr.CallName,
				Modifier = CodeGenerator.ConvertModifier(modifiers, finder),
				TypeReference = typeRef,
				Parameters = CreateParameters(rr, finder, invocationExpr as Ast.InvocationExpression).ToList(),
			};
			
			if (targetClass.ClassType != ClassType.Interface)
				method.Body = CodeGenerator.CreateNotImplementedBlock();
			
			RefactoringDocumentAdapter documentWrapper = new RefactoringDocumentAdapter(editor.Document);
			
			if (isExtension) {
				method.Parameters.Insert(0, new Ast.ParameterDeclarationExpression(CodeGenerator.ConvertType(rr.Target, finder), "thisInstance"));
				method.IsExtensionMethod = true;
				method.Modifier |= Ast.Modifiers.Static;
			}
			
			if (isNew) {
				Ast.TypeDeclaration newType = new Ast.TypeDeclaration(isExtension ? Ast.Modifiers.Static : Ast.Modifiers.None, null);
				newType.Name = result as string;
				newType.AddChild(method);
				gen.InsertCodeAfter(targetClass, documentWrapper, newType);
			} else {
				if (IsEqualClass(rr.CallingClass, targetClass))
					gen.InsertCodeAfter(rr.CallingMember, documentWrapper, method);
				else
					gen.InsertCodeAtEnd(targetClass.BodyRegion, documentWrapper, method);
			}
			
			if (targetClass.ClassType == ClassType.Interface)
				return;
			
			ParseInformation info = ParserService.ParseFile(targetClass.CompilationUnit.FileName);
			if (info != null) {
				IMember newMember;
				
				if (isNew)
					targetClass = info.CompilationUnit.Classes.FirstOrDefault(c => c.DotNetName == c.Namespace + "." + (result as string));
				else
					targetClass = info.CompilationUnit.Classes.Flatten(c => c.InnerClasses).FirstOrDefault(c => c.DotNetName == targetClass.DotNetName);
				
				if (targetClass == null)
					return;
				
				if (IsEqualClass(rr.CallingClass, targetClass)) {
					newMember = targetClass.GetInnermostMember(editor.Caret.Line, editor.Caret.Column);
					newMember = targetClass.AllMembers
						.OrderBy(m => m.BodyRegion.BeginLine)
						.ThenBy(m2 => m2.BodyRegion.BeginColumn)
						.First(m3 => m3.BodyRegion.BeginLine > newMember.BodyRegion.BeginLine);
				} else {
					newMember = targetClass.Methods.Last();
				}
				
				IDocumentLine line = editor.Document.GetLine(newMember.BodyRegion.BeginLine + 2);
				int indentLength = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset).Length;
				editor.Select(line.Offset + indentLength, "throw new NotImplementedException();".Length);
			}
		}
Example #12
0
		public override object VisitAttributeSection(NRefactoryAST.AttributeSection attributeSection, object data)
		{
			if (GetCurrentClass() == null) {
				ClassFinder cf = new ClassFinder(new DefaultClass(cu, "DummyClass"), attributeSection.StartLocation.Line, attributeSection.StartLocation.Column);
				cu.Attributes.AddRange(VisitAttributes(new[] { attributeSection }, cf));
			}
			return null;
		}
Example #13
0
		List<IAttribute> VisitAttributes(IList<NRefactoryAST.AttributeSection> attributes, ClassFinder context)
		{
			// TODO Expressions???
			List<IAttribute> result = new List<IAttribute>();
			foreach (NRefactoryAST.AttributeSection section in attributes) {
				
				AttributeTarget target = AttributeTarget.None;
				if (section.AttributeTarget != null && section.AttributeTarget != "") {
					switch (section.AttributeTarget.ToUpperInvariant()) {
						case "ASSEMBLY":
							target = AttributeTarget.Assembly;
							break;
						case "FIELD":
							target = AttributeTarget.Field;
							break;
						case "EVENT":
							target = AttributeTarget.Event;
							break;
						case "METHOD":
							target = AttributeTarget.Method;
							break;
						case "MODULE":
							target = AttributeTarget.Module;
							break;
						case "PARAM":
							target = AttributeTarget.Param;
							break;
						case "PROPERTY":
							target = AttributeTarget.Property;
							break;
						case "RETURN":
							target = AttributeTarget.Return;
							break;
						case "TYPE":
							target = AttributeTarget.Type;
							break;
						default:
							target = AttributeTarget.None;
							break;
							
					}
				}
				
				foreach (NRefactoryAST.Attribute attribute in section.Attributes) {
					List<object> positionalArguments = new List<object>();
					foreach (NRefactoryAST.Expression positionalArgument in attribute.PositionalArguments) {
						positionalArguments.Add(ConvertAttributeArgument(positionalArgument));
					}
					Dictionary<string, object> namedArguments = new Dictionary<string, object>();
					foreach (NRefactoryAST.NamedArgumentExpression namedArgumentExpression in attribute.NamedArguments) {
						namedArguments.Add(namedArgumentExpression.Name, ConvertAttributeArgument(namedArgumentExpression.Expression));
					}
					result.Add(new DefaultAttribute(new AttributeReturnType(context, attribute.Name),
					                                target, positionalArguments, namedArguments)
					           {
					           	CompilationUnit = cu,
					           	Region = GetRegion(attribute.StartLocation, attribute.EndLocation)
					           });
				}
			}
			return result;
		}
Example #14
0
		void ConvertAttributes(NRefactoryAST.AttributedNode from, AbstractEntity to)
		{
			if (from.Attributes.Count == 0) {
				to.Attributes = DefaultAttribute.EmptyAttributeList;
			} else {
				ICSharpCode.NRefactory.Location location = from.Attributes[0].StartLocation;
				ClassFinder context;
				if (to is IClass) {
					context = new ClassFinder((IClass)to, location.Line, location.Column);
				} else {
					context = new ClassFinder(to.DeclaringType, location.Line, location.Column);
				}
				to.Attributes = VisitAttributes(from.Attributes, context);
			}
		}
		static bool TryDeclarationTypeInference(ITextEditor editor, IDocumentLine curLine)
		{
			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText));
			if (lexer.NextToken().Kind != Tokens.Dim)
				return false;
			if (lexer.NextToken().Kind != Tokens.Identifier)
				return false;
			if (lexer.NextToken().Kind != Tokens.As)
				return false;
			Token t1 = lexer.NextToken();
			if (t1.Kind != Tokens.QuestionMark)
				return false;
			Token t2 = lexer.NextToken();
			if (t2.Kind != Tokens.Assign)
				return false;
			string expr = lineText.Substring(t2.Location.Column);
			LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
			ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
			                                         editor.Caret.Line,
			                                         t2.Location.Column, editor.FileName,
			                                         editor.Document.Text);
			if (rr != null && rr.ResolvedType != null) {
				ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.Caret.Line, t1.Location.Column);
				VBNetAmbience ambience = new VBNetAmbience();
				if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
					ambience.ConversionFlags = ConversionFlags.None;
				else
					ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames;
				string typeName = ambience.Convert(rr.ResolvedType);
				using (editor.Document.OpenUndoGroup()) {
					int offset = curLine.Offset + t1.Location.Column - 1;
					editor.Document.Remove(offset, 1);
					editor.Document.Insert(offset, typeName);
				}
				editor.Caret.Column += typeName.Length - 1;
				return true;
			}
			return false;
		}
		bool TryDeclarationTypeInference(SharpDevelopTextAreaControl editor, LineSegment curLine)
		{
			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.CSharp, new System.IO.StringReader(lineText));
			Token typeToken = lexer.NextToken();
			if (typeToken.kind == CSTokens.Question) {
				if (lexer.NextToken().kind == CSTokens.Identifier) {
					Token t = lexer.NextToken();
					if (t.kind == CSTokens.Assign) {
						string expr = lineText.Substring(t.col);
						LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
						ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
						                                         editor.ActiveTextAreaControl.Caret.Line + 1,
						                                         t.col, editor.FileName,
						                                         editor.Document.TextContent);
						if (rr != null && rr.ResolvedType != null) {
							ClassFinder context = new ClassFinder(editor.FileName, editor.ActiveTextAreaControl.Caret.Line, t.col);
							if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
								CSharpAmbience.Instance.ConversionFlags = ConversionFlags.None;
							else
								CSharpAmbience.Instance.ConversionFlags = ConversionFlags.UseFullyQualifiedNames;
							string typeName = CSharpAmbience.Instance.Convert(rr.ResolvedType);
							editor.Document.Replace(curLine.Offset + typeToken.col - 1, 1, typeName);
							editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
							return true;
						}
					}
				}
			}
			return false;
		}
		void ConvertAttributes(AST.TypeMember node, AbstractEntity to)
		{
			if (node.Attributes.Count == 0) {
				to.Attributes = DefaultAttribute.EmptyAttributeList;
			} else {
				ClassFinder context;
				if (to is IClass) {
					context = new ClassFinder((IClass)to, node.LexicalInfo.Line, node.LexicalInfo.Column);
				} else {
					context = new ClassFinder(to.DeclaringType, node.LexicalInfo.Line, node.LexicalInfo.Column);
				}
				foreach (AST.Attribute a in node.Attributes) {
					to.Attributes.Add(new DefaultAttribute(new AttributeReturnType(context, a.Name)) {
					                  	CompilationUnit = _cu,
					                  	Region = GetRegion(a)
					                  });
				}
			}
			to.Documentation = node.Documentation;
		}
		public override bool InsertAction(TextArea textArea, char ch)
		{
			ClassFinder context = new ClassFinder(ParserService.GetParseInformation(textArea.MotherTextEditorControl.FileName),
			                                      textArea.Caret.Line + 1, textArea.Caret.Column + 1);
			int caretPosition = textArea.Caret.Offset;
			LineSegment line = textArea.Document.GetLineSegment(textArea.Caret.Line);
			string lineText = textArea.Document.GetText(line.Offset, caretPosition - line.Offset);
			foreach (char c in lineText) {
				if (!char.IsWhiteSpace(c) && !char.IsLetterOrDigit(c)) {
					return base.InsertAction(textArea, ch);
				}
			}
			string indentation = lineText.Substring(0, lineText.Length - lineText.TrimStart().Length);
			
			CodeGenerator codeGen = ParserService.CurrentProjectContent.Language.CodeGenerator;
			
			string text = codeGen.GenerateCode(codeGen.GetOverridingMethod(member, context), indentation);
			text = text.TrimEnd(); // remove newline from end
			textArea.Document.Replace(line.Offset, caretPosition - line.Offset, text);
			
			int endPos = line.Offset + text.Length;
			int endLine = textArea.Document.GetLineNumberForOffset(endPos);
			line = textArea.Document.GetLineSegment(endLine);
			textArea.MotherTextAreaControl.JumpTo(endLine, endPos - line.Offset);
			textArea.Refresh();
			return true;
		}
		Variable ResolveVariable(Variable variable)
		{
			Dom.ParseInformation info = ParserService.GetParseInformation(this.textEditor.FileName);
			Dom.ExpressionResult res = new Dom.ExpressionResult(variable.Name,
			                                                    Dom.DomRegion.FromLocation(variable.StartPos, variable.EndPos),
			                                                    Dom.ExpressionContext.Default, null);
			Dom.ResolveResult result = this.GetResolver().Resolve(res, info, this.textEditor.Document.Text);
			
			Dom.IReturnType type = currentProjectContent.SystemTypes.Object;
			Dom.ClassFinder finder = new Dom.ClassFinder(currentClass, textEditor.Caret.Line, textEditor.Caret.Column);
			
			if (result != null && result.ResolvedType != null)
				type = result.ResolvedType;
			
			if (variable.Type.Type == "var")
				variable.Type = Dom.Refactoring.CodeGenerator.ConvertType(type, finder);
			
			variable.IsReferenceType = type.IsReferenceType == true;
			
			return variable;
		}