public TemplateParameterSymbol(TemplateParameter tpn, ISemantic typeOrValue, ISyntaxRegion paramIdentifier = null) : base(tpn != null ? tpn.Representation : null, AbstractType.Get(typeOrValue), paramIdentifier) { IsKnowinglyUndetermined = TemplateInstanceHandler.IsNonFinalArgument(typeOrValue); this.Parameter = tpn; this.ParameterValue = typeOrValue as ISymbolValue; }
public bool HandleDecl(TemplateTypeParameter p, ITypeDeclaration td, ISemantic rr) { if (td is IdentifierDeclaration) { return(HandleDecl(p, (IdentifierDeclaration)td, rr)); } if (TemplateInstanceHandler.IsNonFinalArgument(rr)) { foreach (var tp in this.TargetDictionary.Keys.ToList()) { if (TargetDictionary[tp] == null) { TargetDictionary[tp] = new TemplateParameterSymbol(tp, null); } } return(true); } //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); }
/// <summary> /// Checks given results for type equality /// </summary> public static bool IsEqual(ISemantic r1, ISemantic r2) { if (r1 == r2) { return(true); } if (r1 is TemplateParameterSymbol) { var tps1 = r1 as TemplateParameterSymbol; var tps2 = r2 as TemplateParameterSymbol; if (tps2 != null && tps1.Parameter == tps2.Parameter) { return((tps1.Base == null && tps2.Base == null) || IsEqual(tps1.Base, tps2.Base)); } if (TemplateInstanceHandler.IsNonFinalArgument(r2)) { return(true); } r1 = tps1.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); }