UFCSResolver(ResolutionContext ctxt, ISemantic firstArg, int nameHash = 0, ISyntaxRegion sr = null)
     : base(ctxt)
 {
     this.firstArgument = firstArg;
     this.nameFilterHash = nameHash;
     this.sr = sr;
 }

		bool HandleDecl(TemplateTypeParameter p, IdentifierDeclaration id, ISemantic r)
		{
			// Bottom-level reached
			if (id.InnerDeclaration == null && Contains(id.IdHash) && !id.ModuleScoped)
			{
				// Associate template param with r
				return Set((p != null && id.IdHash == p.NameHash) ? p : null, r, id.IdHash);
			}

			var deducee = DResolver.StripMemberSymbols(AbstractType.Get(r)) as DSymbol;
			if (id.InnerDeclaration != null && deducee != null && deducee.Definition.NameHash == id.IdHash)
			{
				var physicalParentType = TypeDeclarationResolver.HandleNodeMatch(deducee.Definition.Parent, ctxt, null, id.InnerDeclaration);
				if (HandleDecl(p, id.InnerDeclaration, physicalParentType))
				{
					if (Contains(id.IdHash))
						Set((p != null && id.IdHash == p.NameHash) ? p : null, deducee, id.IdHash);
					return true;
				}
			}

			/*
			 * If not stand-alone identifier or is not required as template param, resolve the id and compare it against r
			 */
			var _r = TypeDeclarationResolver.ResolveSingle(id, ctxt);

			return _r != null && (EnforceTypeEqualityWhenDeducing ?
				ResultComparer.IsEqual(r,_r) :
				ResultComparer.IsImplicitlyConvertible(r,_r));
		}

        public IEnumerable<DMethod> FindFitting(ResolverContextStack ctxt, CodeLocation currentLocation, ISemantic firstArgument, string nameFilter = null)
        {
            if (IsProcessing)
                return null;

            var preMatchList = new List<DMethod>();

            bool dontUseNameFilter = nameFilter == null;

            lock(CachedMethods)
                foreach (var kv in CachedMethods)
                {
                    // First test if arg is matching the parameter
                    if ((dontUseNameFilter || kv.Key.Name == nameFilter) &&
                        ResultComparer.IsImplicitlyConvertible(firstArgument, kv.Value, ctxt))
                        preMatchList.Add(kv.Key);
                }

            // Then filter out methods which cannot be accessed in the current context
            // (like when the method is defined in a module that has not been imported)
            var mv = new MatchFilterVisitor<DMethod>(ctxt, preMatchList);

            mv.IterateThroughScopeLayers(currentLocation);

            return mv.filteredList;
        }

        /// <summary>
        /// Checks given results for type equality
        /// </summary>
        public static bool IsEqual(ISemantic r1, ISemantic r2)
        {
            if (r1 is ISymbolValue && r2 is ISymbolValue)
                return SymbolValueComparer.IsEqual((ISymbolValue)r1, (ISymbolValue)r2);

            else if (r1 is TemplateIntermediateType && r2 is TemplateIntermediateType)
            {
                var tr1 = (TemplateIntermediateType)r1;
                var tr2 = (TemplateIntermediateType)r2;

                if (tr1.Definition != tr2.Definition)
                    return false;

                //TODO: Compare deduced types
                return true;
            }
            else if (r1 is PrimitiveType && r2 is PrimitiveType)
                return ((PrimitiveType)r1).TypeToken == ((PrimitiveType)r2).TypeToken;
            else if (r1 is ArrayType && r2 is ArrayType)
            {
                var ar1 = (ArrayType)r1;
                var ar2 = (ArrayType)r2;

                if (!IsEqual(ar1.KeyType, ar2.KeyType))
                    return false;

                return IsEqual(ar1.Base, ar2.Base);
            }

            //TODO: Handle other types

            return false;
        }

        public bool HandleDecl(TemplateTypeParameter p ,ITypeDeclaration td, ISemantic rr)
        {
            if (td is IdentifierDeclaration)
                return HandleDecl(p,(IdentifierDeclaration)td, rr);

            //HACK Ensure that no information gets lost by using this function
            // -- getting a value but requiring an abstract type and just extract it from the value - is this correct behaviour?
            var at = AbstractType.Get(rr);

            if (td is ArrayDecl)
                return HandleDecl(p,(ArrayDecl)td, DResolver.StripMemberSymbols(at) as AssocArrayType);
            else if (td is DTokenDeclaration)
                return HandleDecl((DTokenDeclaration)td, at);
            else if (td is DelegateDeclaration)
                return HandleDecl(p, (DelegateDeclaration)td, DResolver.StripMemberSymbols(at) as DelegateType);
            else if (td is PointerDecl)
                return HandleDecl(p, (PointerDecl)td, DResolver.StripMemberSymbols(at) as PointerType);
            else if (td is MemberFunctionAttributeDecl)
                return HandleDecl(p,(MemberFunctionAttributeDecl)td, at);
            else if (td is TypeOfDeclaration)
                return HandleDecl((TypeOfDeclaration)td, at);
            else if (td is VectorDeclaration)
                return HandleDecl((VectorDeclaration)td, at);
            else if (td is TemplateInstanceExpression)
                return HandleDecl(p,(TemplateInstanceExpression)td, at);

            return false;
        }

        ISemantic E(OperatorBasedExpression x, ISemantic lValue=null)
        {
            if (x is AssignExpression)
                return E((AssignExpression)x,lValue);

            // TODO: Implement operator precedence (see http://forum.dlang.org/thread/[email protected] )

            if (x is XorExpression || // a ^ b
                x is OrExpression || // a | b
                x is AndExpression || // a & b
                x is ShiftExpression || // a << 8
                x is AddExpression || // a += b; a -= b;
                x is MulExpression || // a *= b; a /= b; a %= b;
                x is CatExpression || // a ~= b;
                x is PowExpression) // a ^^ b;
                return E_MathOp(x, lValue);

            else if (x is EqualExpression) // a==b
                return E((EqualExpression)x, lValue);

            else if (x is OrOrExpression || // a || b
                x is AndAndExpression || // a && b
                x is IdendityExpression || // a is T
                x is RelExpression) // a <= b
                return E_BoolOp(x, lValue as ISymbolValue);

            else if (x is InExpression) // a in b
                return E((InExpression)x, lValue);

            throw new WrongEvaluationArgException();
        }

        /// <summary>
        /// Checks given results for type equality
        /// </summary>
        public static bool IsEqual(ISemantic r1, ISemantic r2)
        {
            if(r1 is TemplateParameterSymbol)
                r1 = ((TemplateParameterSymbol)r1).Base;
            if(r2 is TemplateParameterSymbol)
                r2 = ((TemplateParameterSymbol)r2).Base;

            if (r1 is ISymbolValue && r2 is ISymbolValue)
                return SymbolValueComparer.IsEqual((ISymbolValue)r1, (ISymbolValue)r2);

            else if (r1 is TemplateIntermediateType && r2 is TemplateIntermediateType)
            {
                var tr1 = (TemplateIntermediateType)r1;
                var tr2 = (TemplateIntermediateType)r2;

                if (tr1.Definition != tr2.Definition)
                    return false;

                //TODO: Compare deduced types
                return true;
            }
            else if (r1 is PrimitiveType && r2 is PrimitiveType)
                return ((PrimitiveType)r1).TypeToken == ((PrimitiveType)r2).TypeToken;
            else if (r1 is ArrayType && r2 is ArrayType)
            {
                var ar1 = (ArrayType)r1;
                var ar2 = (ArrayType)r2;

                if (!IsEqual(ar1.KeyType, ar2.KeyType))
                    return false;

                return IsEqual(ar1.Base, ar2.Base);
            }
            else if(r1 is DelegateType && r2 is DelegateType)
            {
                var dg1 = r1 as DelegateType;
                var dg2 = r2 as DelegateType;

                if(dg1.IsFunctionLiteral != dg2.IsFunctionLiteral ||
                   !IsEqual(dg1.ReturnType, dg2.ReturnType))
                    return false;

                if(dg1.Parameters == null || dg1.Parameters.Length == 0)
                    return dg2.Parameters == null || dg2.Parameters.Length==0;
                else if(dg2.Parameters == null)
                    return dg1.Parameters == null || dg1.Parameters.Length==0;
                else if(dg1.Parameters.Length == dg2.Parameters.Length)
                {
                    for(int i = dg1.Parameters.Length-1; i != 0; i--)
                        if(!IsEqual(dg1.Parameters[i], dg2.Parameters[i]))
                            return false;
                    return true;
                }
            }

            //TODO: Handle other types

            return false;
        }

 public static AbstractType Convert(ISemantic s)
 {
     if (s is AbstractType)
         return (AbstractType)s;
     else if(s is ISymbolValue)
         return ((ISymbolValue)s).RepresentedType;
     return null;
 }

		bool Handle(TemplateAliasParameter p, ISemantic arg)
		{
			#region Handle parameter defaults
			if (arg == null)
			{
				if (p.DefaultExpression != null)
				{
					var eval = Evaluation.EvaluateValue(p.DefaultExpression, ctxt);

					if (eval == null)
						return false;

					return Set(p, eval, 0);
				}
				else if (p.DefaultType != null)
				{
					var res = TypeDeclarationResolver.ResolveSingle(p.DefaultType, ctxt);

					return res != null && Set(p, res, 0);
				}
				return false;
			}
			#endregion

			#region Given argument must be a symbol - so no built-in type but a reference to a node or an expression
			var t=AbstractType.Get(arg);
			
			if (t == null)
				return false;
			
			if(!(t is DSymbol))
				while (t != null)
				{
					if (t is PrimitiveType) // arg must not base on a primitive type.
						return false;
	
					if (t is DerivedDataType)
						t = ((DerivedDataType)t).Base;
					else
						break;
				}
			#endregion

			#region Specialization check
			if (p.SpecializationExpression != null)
			{
				// LANGUAGE ISSUE: Can't do anything here - dmd won't let you use MyClass!(2) though you have class MyClass(alias X:2)
				return false;
			}
			else if (p.SpecializationType != null)
			{
				// ditto
				return false;
			}
			#endregion

			return Set(p,arg,0);
		}

		public static MemberSymbol[] TryResolveUFCS(
			ISemantic firstArgument, 
			PostfixExpression_Access acc, 
			ResolutionContext ctxt)
		{
			if (ctxt == null)
				return null;
			
			int name=0;

			if (acc.AccessExpression is IdentifierExpression)
				name = ((IdentifierExpression)acc.AccessExpression).ValueStringHash;
			else if (acc.AccessExpression is TemplateInstanceExpression)
				name = ((TemplateInstanceExpression)acc.AccessExpression).TemplateIdHash;
			else
				return null;

			var methodMatches = new List<MemberSymbol>();
			if(ctxt.ParseCache!=null)
				foreach (var pc in ctxt.ParseCache)
				{
					var tempResults=pc.UfcsCache.FindFitting(ctxt, acc.Location, firstArgument, name);

					if (tempResults != null)
						foreach (var m in tempResults)
						{
							ctxt.PushNewScope(m);

							if (m.TemplateParameters != null && m.TemplateParameters.Length != 0)
							{
								var ov = TemplateInstanceHandler.DeduceParamsAndFilterOverloads(
									new[] { new MemberSymbol(m, null, acc) }, 
									new[] { firstArgument }, true, ctxt);

								if (ov == null || ov.Length == 0)
									continue;

								var ms = (DSymbol)ov[0];
								ctxt.CurrentContext.IntroduceTemplateParameterTypes(ms);
							}
							
							var mr = TypeDeclarationResolver.HandleNodeMatch(m, ctxt, null, acc) as MemberSymbol;
							if (mr!=null)
							{
								mr.FirstArgument = firstArgument;
								mr.DeducedTypes = ctxt.CurrentContext.DeducedTemplateParameters.ToReadonly();
								mr.IsUFCSResult = true;
								methodMatches.Add(mr);
							}
							ctxt.Pop();
						}
				}

			return methodMatches.Count == 0 ? null : methodMatches.ToArray();
		}

        public static List<AbstractType> TryResolveUFCS(
			ISemantic firstArgument,int nameHash,CodeLocation nameLoc,
			ResolutionContext ctxt, ISyntaxRegion nameSr = null)
        {
            if (firstArgument == null || ctxt == null)
                return new List<AbstractType>();

            var us = new UFCSResolver (ctxt, firstArgument, nameHash, nameSr);
            us.IterateThroughScopeLayers (nameLoc, MemberFilter.Methods | MemberFilter.Templates);
            return us.matches;
        }

        public static void AddArrayProperties(ISemantic rr, ICompletionDataGenerator cdg, ArrayDecl ArrayDecl = null)
        {
            CreateArtificialProperties(ArrayProps, cdg, ArrayDecl);

            cdg.Add(new DVariable
            {
                Name = "ptr",
                Description = "Returns pointer to the array",
                Type = new PointerDecl(ArrayDecl == null ? new DTokenDeclaration(DTokens.Void) : ArrayDecl.ValueType)
            });
        }

		ISemantic E(AssignExpression x, ISemantic lValue=null)
		{
			if (!eval)
				return E(x.LeftOperand);

			var l = TryGetValue(lValue ?? E(x.LeftOperand));

			//TODO

			return null;
		}

 public static void Generate(ISemantic rr, ResolutionContext ctxt, IEditorData ed, ICompletionDataGenerator gen)
 {
     if(ed.ParseCache!=null)
         foreach (var pc in ed.ParseCache)
             if (pc != null && pc.UfcsCache != null && pc.UfcsCache.CachedMethods != null)
             {
                 var r=pc.UfcsCache.FindFitting(ctxt, ed.CaretLocation, rr);
                 if(r!=null)
                     foreach (var m in r)
                         gen.Add(m);
             }
 }

        static AbstractTooltipContent BuildTooltipContent(ISemantic res)
        {
            // Only show one description for items sharing descriptions
            string description = res is DSymbol ? ((DSymbol)res).Definition.Description : "";

            return new AbstractTooltipContent
            {
                ResolveResult = res,
                Title = (res is ModuleSymbol ? ((ModuleSymbol)res).Definition.FileName : res.ToString()),
                Description = description
            };
        }

        public static AbstractType Get(ISemantic s)
        {
            //FIXME: What to do with the other overloads?
            if (s is InternalOverloadValue)
                return (s as InternalOverloadValue).Overloads[0];
            if (s is VariableValue)
                return (s as VariableValue).Member;
            if (s is ISymbolValue)
                return (s as ISymbolValue).RepresentedType;

            return s as AbstractType;
        }

        public static bool IsUfcsResult(AbstractType t, out ISemantic firstArgument)
        {
            var o = t.Tag as UfcsTag;

            if (o == null) {
                firstArgument = null;
                return false;
            }

            firstArgument = o.firstArgument;
            return true;
        }

        static AbstractTooltipContent BuildTooltipContent(ISemantic res)
        {
            // Only show one description for items sharing descriptions
            var ds = res as DSymbol;
            var description = ds != null ? ds.Definition.Description : "";

            return new AbstractTooltipContent
            {
                ResolveResult = res,
                Title = BuildTooltipTitle(res),
                Description = description
            };
        }

        public bool Handle(TemplateParameter parameter, ISemantic argumentToAnalyze)
        {
            // Packages aren't allowed at all
            if (argumentToAnalyze is PackageSymbol)
                return false;

            // Module symbols can be used as alias only
            if (argumentToAnalyze is ModuleSymbol &&
                !(parameter is TemplateAliasParameter))
                return false;

            //TODO: Handle __FILE__ and __LINE__ correctly - so don't evaluate them at the template declaration but at the point of instantiation

            /*
             * Introduce previously deduced parameters into current resolution context
             * to allow value parameter to be of e.g. type T whereas T is already set somewhere before
             */
            DeducedTypeDictionary _prefLocalsBackup = null;
            if (ctxt != null && ctxt.CurrentContext != null)
            {
                _prefLocalsBackup = ctxt.CurrentContext.DeducedTemplateParameters;

                var d = new DeducedTypeDictionary();
                foreach (var kv in TargetDictionary)
                    if (kv.Value != null)
                        d[kv.Key] = kv.Value;
                ctxt.CurrentContext.DeducedTemplateParameters = d;
            }

            bool res = false;

            if (parameter is TemplateAliasParameter)
                res = Handle((TemplateAliasParameter)parameter, argumentToAnalyze);
            else if (parameter is TemplateThisParameter)
                res = Handle((TemplateThisParameter)parameter, argumentToAnalyze);
            else if (parameter is TemplateTypeParameter)
                res = Handle((TemplateTypeParameter)parameter, argumentToAnalyze);
            else if (parameter is TemplateValueParameter)
                res = Handle((TemplateValueParameter)parameter, argumentToAnalyze);
            else if (parameter is TemplateTupleParameter)
                res = Handle((TemplateTupleParameter)parameter, new[] { argumentToAnalyze });

            if (ctxt != null && ctxt.CurrentContext != null)
                ctxt.CurrentContext.DeducedTemplateParameters = _prefLocalsBackup;

            return res;
        }

		bool Handle(TemplateValueParameter p, ISemantic arg)
		{
			// Handle default arg case
			if (arg == null)
			{
				if (p.DefaultExpression != null)
				{
					var eval = Evaluation.EvaluateValue(p.DefaultExpression, ctxt);

					if (eval == null)
						return false;

					return Set(p, eval, 0);
				}
				else
					return false;
			}

			var valueArgument = arg as ISymbolValue;

			// There must be a constant expression given!
			if (valueArgument == null)
				return false;

			// Check for param type <-> arg expression type match
			var paramType = TypeDeclarationResolver.Resolve(p.Type, ctxt);

			if (paramType == null || paramType.Length == 0)
				return false;

			if (valueArgument.RepresentedType == null ||
				!ResultComparer.IsImplicitlyConvertible(paramType[0], valueArgument.RepresentedType))
				return false;

			// If spec given, test for equality (only ?)
			if (p.SpecializationExpression != null) 
			{
				var specVal = Evaluation.EvaluateValue(p.SpecializationExpression, ctxt);

				if (specVal == null || !SymbolValueComparer.IsEqual(specVal, valueArgument))
					return false;
			}

			return Set(p, arg, 0);
		}