public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td,
AbstractType baseType = null, InterfaceType[] baseInterfaces = null,
ReadOnlyCollection <TemplateParameterSymbol> deducedTypes = null)
: base(dc, baseType, deducedTypes, td)
{
this.BaseInterfaces = baseInterfaces;
}
public static Range GetNameRange(this ISyntaxRegion reference)
{
CodeLocation startLocation;
CodeLocation endLocation;
switch (reference)
{
case AbstractTypeDeclaration abstractTypeDeclaration:
startLocation = abstractTypeDeclaration.NonInnerTypeDependendLocation;
endLocation = abstractTypeDeclaration.EndLocation;
break;
case IExpression _:
startLocation = reference.Location;
endLocation = reference.EndLocation;
break;
case TemplateParameter templateParameter:
startLocation = templateParameter.NameLocation;
endLocation = new CodeLocation(templateParameter.NameLocation.Column + templateParameter.Name.Length,
templateParameter.NameLocation.Line);
break;
case INode n:
startLocation = n.NameLocation;
endLocation = new CodeLocation(n.NameLocation.Column + n.Name.Length, n.NameLocation.Line);
break;
default:
return(default);
}
return(new Range(new Position(startLocation.Line - 1, startLocation.Column - 1),
new Position(endLocation.Line - 1, endLocation.Column - 1)));
}
public bool TryGet(ResolutionContext ctxt, ISyntaxRegion element, out T resolvedElement)
{
resolvedElement = null;
var parameters = GetParameters(ctxt, GetRelatedNode(element));
if (parameters.Count == 0)
{
lock (paramLessCache)
return(paramLessCache.TryGetValue(element, out resolvedElement));
}
lock (paramBoundCache)
{
Dictionary <TemplateParameterSymbol[], T> dict;
if (!paramBoundCache.TryGetValue(element, out dict))
{
return(false);
}
foreach (var kv in dict)
{
if (CompareParameterEquality(parameters, kv.Key))
{
resolvedElement = kv.Value;
return(true);
}
}
}
return(false);
}
public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td,
AbstractType baseType, InterfaceType[] baseInterfaces,
IEnumerable <TemplateParameterSymbol> deducedTypes)
: this(dc, td, baseType, baseInterfaces,
deducedTypes != null ? new ReadOnlyCollection <TemplateParameterSymbol>(deducedTypes.ToArray()) : null)
{
}
static ISyntaxRegion GetLastBlockAstChild(DBlockNode n)
{
ISyntaxRegion lastChild = null;
ISyntaxRegion t = null;
if (n.Count != 0)
{
lastChild = n.Children[n.Count - 1];
}
if (n.MetaBlocks.Count != 0)
{
t = n.MetaBlocks[n.MetaBlocks.Count - 1];
if (lastChild == null || t.EndLocation > lastChild.EndLocation)
{
lastChild = t;
}
}
if (n.StaticStatements.Count != 0)
{
t = n.StaticStatements[n.StaticStatements.Count - 1];
if (lastChild == null || t.EndLocation > lastChild.EndLocation)
{
lastChild = t;
}
}
return(lastChild);
}
/// <summary>
/// Adds a result to the cache.
/// Warning: Does not check for double occurences of the same set of surrounding template parameters -
/// so call TryGet first to ensure that the element hasn't been enlisted yet under these specific circumstances.
/// </summary>
public void Add(ResolutionContext ctxt, ISyntaxRegion element, T resolvedElement)
{
var parameters = GetParameters(ctxt, GetRelatedNode(element));
if (resolvedElement is AbstractType &&
(resolvedElement as AbstractType).DeclarationOrExpressionBase == element)
{
(resolvedElement as AbstractType).DeclarationOrExpressionBase = null;
}
if (parameters.Count == 0)
{
try{
lock (paramLessCache)
paramLessCache.Add(element, resolvedElement);
}catch (Exception)
{
}
return;
}
lock (paramBoundCache)
{
Dictionary <TemplateParameterSymbol[], T> dict;
if (!paramBoundCache.TryGetValue(element, out dict))
{
dict = new Dictionary <TemplateParameterSymbol[], T>();
paramBoundCache.Add(element, dict);
}
dict.Add(parameters.ToArray(), resolvedElement);
}
}
public static Range ToRange(this ISyntaxRegion syntaxRegion)
{
return(syntaxRegion == null ? null
: new Range(
new Position(syntaxRegion.Location.Line - 1, syntaxRegion.Location.Column - 1),
new Position(syntaxRegion.EndLocation.Line - 1, syntaxRegion.EndLocation.Column - 1)));
}
private bool PushSelectionRange(ISyntaxRegion syntaxRegion)
{
if (syntaxRegion is DModule)
{
return(true);
}
if (syntaxRegion.Location > caret || syntaxRegion.EndLocation < caret)
{
return(false);
}
if (narrowestSelectionRange == null)
{
narrowestSelectionRange = new SelectionRange {
Range = syntaxRegion.ToRange()
};
}
else if (syntaxRegion.IsWithinRange(narrowestSelectionRange.Range))
{
narrowestSelectionRange = new SelectionRange
{
Range = syntaxRegion.ToRange(),
Parent = narrowestSelectionRange
};
}
return(true);
}
public static AbstractType[] ResolveFurtherTypeIdentifier(string nextIdentifier,
IEnumerable <AbstractType> resultBases,
ResolutionContext ctxt,
ISyntaxRegion typeIdObject = null)
{
return(ResolveFurtherTypeIdentifier(nextIdentifier.GetHashCode(), resultBases, ctxt, typeIdObject));
}
/// <summary>
/// Used to extract the adequate code location + the identifier length
/// </summary>
public static CodeLocation ExtractIdLocation(ISyntaxRegion sr, out int idLength)
{
if (sr is IdentifierDeclaration)
{
var id = (IdentifierDeclaration)sr;
idLength = id.Id.Length;
return(id.Location);
}
else if (sr is IdentifierExpression)
{
var id = (IdentifierExpression)sr;
idLength = ((string)id.Value).Length;
return(id.Location);
}
else if (sr is TemplateInstanceExpression)
{
var tix = (TemplateInstanceExpression)sr;
idLength = tix.TemplateIdentifier.Id.Length;
return(tix.TemplateIdentifier.Location);
}
else if (sr is PostfixExpression_Access)
{
return(ExtractIdLocation(((PostfixExpression_Access)sr).AccessExpression, out idLength));
}
else if (sr is NewExpression)
{
return(ExtractIdLocation(((NewExpression)sr).Type, out idLength));
}
idLength = 0;
return(CodeLocation.Empty);
}
public ulong Accept(ISyntaxRegion sr)
{
if (sr is INode)
{
return((sr as INode).Accept(this));
}
if (sr is IExpression)
{
return((ulong)sr.ToString().GetHashCode()); // Temporary bypass
//return (sr as IExpression).Accept(this);
}
if (sr is IStatement)
{
return((sr as IStatement).Accept(this));
}
if (sr is ITypeDeclaration)
{
return((sr as ITypeDeclaration).Accept(this));
}
if (sr is DAttribute)
{
return((sr as DAttribute).Accept(this));
}
throw new InvalidOperationException();
}
static string GetIdentifier(ISyntaxRegion sr)
{
switch (sr)
{
case INode n:
return(n.Name);
case TemplateInstanceExpression templateInstanceExpression:
return(templateInstanceExpression.TemplateId); // Identifier.ToString(false);
case NewExpression newExpression:
return(newExpression.Type.ToString(false));
case TemplateParameter templateParameter:
return(templateParameter.Name);
case IdentifierDeclaration identifierDeclaration:
return(identifierDeclaration.Id);
case IdentifierExpression identifierExp:
return(identifierExp.StringValue);
default:
return("");
}
}
UFCSResolver(ResolutionContext ctxt, ISemantic firstArg, int nameHash = 0, ISyntaxRegion sr = null)
: base(ctxt)
{
this.firstArgument = firstArg;
this.nameFilterHash = nameHash;
this.sr = sr;
}
bool TryAdd(AbstractType resolvedSymbol, ISyntaxRegion sr)
{
if (resolvedSymbol != null)
{
INode n;
var aliasTag = resolvedSymbol.Tag as D_Parser.Resolver.TypeResolution.TypeDeclarationResolver.AliasTag;
if (aliasTag != null)
{
n = aliasTag.aliasDefinition;
}
else if (resolvedSymbol is DSymbol)
{
n = (resolvedSymbol as DSymbol).Definition;
}
else
{
n = null;
}
if (n == symbol)
{
l.Add(sr);
return(true);
}
}
return(false);
}
AbstractType TryPretendMethodExecution(AbstractType b, ISyntaxRegion typeBase = null, AbstractType[] args = null)
{
if (!TryReturnMethodReturnType || (ctxt.Options & ResolutionOptions.ReturnMethodReferencesOnly) != 0)
{
return(b);
}
if (b is AmbiguousType)
{
AbstractType first = null;
foreach (var ov in (b as AmbiguousType).Overloads)
{
if (ov is MemberSymbol)
{
var next = TryPretendMethodExecution_(ov as MemberSymbol, args);
if (first == null && next != ov)
{
first = next;
continue;
}
// Error - ambiguous parameter configurations
}
// Error
}
return(first ?? b);
}
var mr = b as MemberSymbol;
return(mr == null ? b : TryPretendMethodExecution_(mr, args));
}
void HandleResult(ISyntaxRegion sr, AbstractType t)
{
if (t is UserDefinedType)
{
result.TypeMatches.Add(sr);
}
}
/// <summary>
/// Used to extract the adequate code location + the identifier length
/// </summary>
public static CodeLocation ExtractIdLocation(ISyntaxRegion sr, out int idLength)
{
if (sr is IdentifierDeclaration)
{
var id = (IdentifierDeclaration)sr;
idLength = id.Id.Length;
return id.Location;
}
else if (sr is IdentifierExpression)
{
var id = (IdentifierExpression)sr;
idLength = id.StringValue.Length;
return id.Location;
}
else if (sr is TemplateInstanceExpression)
{
var tix = (TemplateInstanceExpression)sr;
idLength = tix.TemplateId.Length;
return tix.Identifier.Location;
}
else if (sr is PostfixExpression_Access)
return ExtractIdLocation(((PostfixExpression_Access)sr).AccessExpression, out idLength);
else if (sr is NewExpression)
return ExtractIdLocation(((NewExpression)sr).Type, out idLength);
idLength = 0;
return CodeLocation.Empty;
}
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 TemplateIntermediateType(DClassLike dc, ISyntaxRegion td,
AbstractType baseType, InterfaceType[] baseInterfaces,
Dictionary <string, TemplateParameterSymbol> deducedTypes)
: this(dc, td, baseType, baseInterfaces,
deducedTypes != null && deducedTypes.Count != 0 ? new ReadOnlyCollection <KeyValuePair <string, TemplateParameterSymbol> >(deducedTypes.ToArray()) : null)
{
}
/// <summary>
/// http://dlang.org/operatoroverloading.html#Dispatch
/// Check for the existence of an opDispatch overload.
/// Important: Because static opDispatches are allowed as well, do check whether we can access non-static overloads from non-instance expressions or such
/// </summary>
public static IEnumerable<AbstractType> TryResolveFurtherIdViaOpDispatch (ResolutionContext ctxt, int nextIdentifierHash, UserDefinedType b, ISyntaxRegion typeBase = null)
{
// The usual SO prevention
if (nextIdentifierHash == opDispatchId || b == null)
yield break;
AbstractType[] overloads;
var opt = ctxt.CurrentContext.ContextDependentOptions;
// Look for opDispatch-Members inside b's Definition
using (ctxt.Push(b))
{
ctxt.CurrentContext.ContextDependentOptions = opt; // Mainly required for not resolving opDispatch's return type, as this will be performed later on in higher levels
overloads = TypeDeclarationResolver.ResolveFurtherTypeIdentifier(opDispatchId, b, ctxt, typeBase, false);
}
if (overloads == null || overloads.Length < 0)
yield break;
var av = new ArrayValue (Evaluation.GetStringType(ctxt), Strings.TryGet(nextIdentifierHash));
foreach (DSymbol o in overloads) {
var dn = o.Definition;
if (dn.TemplateParameters != null && dn.TemplateParameters.Length > 0 &&
dn.TemplateParameters[0] is TemplateValueParameter)
{
//TODO: Test parameter types for being a string value
o.SetDeducedTypes(new[]{ new TemplateParameterSymbol(dn.TemplateParameters[0], av) });
yield return o;
}
}
}
public MemberCompletionProvider(ICompletionDataGenerator cdg, ISyntaxRegion sr, IBlockNode b, IStatement stmt)
: base(cdg)
{
AccessExpression = sr;
ScopedBlock = b;
ScopedStatement = stmt;
}
public void GetDefinition(string filename, int startLine, int startIndex, int endLine, int endIndex)
{
filename = normalizePath(filename);
var ast = GetModule(filename);
if (ast == null)
{
throw new COMException("module not found", 1);
}
_tipStart = new CodeLocation(startIndex + 1, startLine);
_tipEnd = new CodeLocation(endIndex + 1, endLine);
_tipText.Clear();
_setupEditorData();
_editorData.CaretLocation = _tipEnd;
_editorData.SyntaxTree = ast as DModule;
_editorData.ModuleCode = _sources[filename];
// codeOffset+1 because otherwise it does not work on the first character
_editorData.CaretOffset = getCodeOffset(_editorData.ModuleCode, _tipStart) + 2;
ISyntaxRegion sr = DResolver.GetScopedCodeObject(_editorData);
LooseResolution.NodeResolutionAttempt attempt;
var rr = sr != null?LooseResolution.ResolveTypeLoosely(_editorData, sr, out attempt, true) : null;
_tipText.Clear();
if (rr != null)
{
var n = DResolver.GetResultMember(rr, true);
if (n == null)
{
return;
}
bool decl = false;
var mthd = n as DMethod;
if (mthd != null)
{
decl = mthd.Body == null;
}
else if (n.ContainsAttribute(DTokens.Extern))
{
decl = true;
}
if (decl)
{
_tipText.Append("EXTERN:");
}
_tipStart = n.Location;
_tipEnd = n.EndLocation;
INode node = n.NodeRoot;
if (node is DModule)
{
_tipText.Append((node as DModule).FileName);
}
}
}
public static List<AbstractType> SearchAndResolve(ResolutionContext ctxt, CodeLocation caret, int nameHash, ISyntaxRegion idObject=null)
{
var scan = new NameScan(ctxt, nameHash, idObject);
scan.IterateThroughScopeLayers(caret);
return scan.matches_types;
}
static Location ToLocation(ISyntaxRegion reference, DModule module)
{
return(new Location
{
Range = reference.GetNameRange(),
Uri = new Uri(module.FileName)
});
}
public AliasedType(DVariable AliasDefinition, AbstractType Type, ISyntaxRegion td, IEnumerable <TemplateParameterSymbol> deducedTypes)
: base(AliasDefinition, Type, td, deducedTypes)
{
if (Type != null)
{
Type.NonStaticAccess = false;
}
}
public override void Visit(PostfixExpression_MethodCall x)
{
base.Visit(x);
if (IdNearCaret == x.PostfixForeExpression)
{
IdNearCaret = x;
}
}
static DocumentHighlight ToDocumentHighlight(ISyntaxRegion syntaxRegion)
{
return(new DocumentHighlight
{
Range = syntaxRegion.GetNameRange(),
Kind = DocumentHighlightKind.Text
});
}
public AmbiguityError(ISyntaxRegion syntaxObj, IEnumerable<ISemantic> results)
: base(syntaxObj, "Resolution returned too many results")
{
if (results is ISemantic[])
this.DetectedOverloads = (ISemantic[])results;
else if(results!=null)
this.DetectedOverloads = results.ToArray();
}
/// <summary>
/// See <see cref="ResolveIdentifier"/>
/// </summary>
public static AbstractType ResolveSingle(string id, ResolutionContext ctxt, ISyntaxRegion idObject, bool ModuleScope = false)
{
var r = ResolveIdentifier(id, ctxt, idObject, ModuleScope);
ctxt.CheckForSingleResult(r, idObject as ISyntaxRegion);
return(r != null && r.Length != 0 ? r[0] : null);
}
static string GetMixinContent(MixinStatement mx, ResolutionContext ctxt, bool takeStmtCache ,out ISyntaxRegion cachedContent)
{
cachedContent = null;
if(!CheckAndPushAnalysisStack(mx))
return null;
bool pop;
if(pop = (ctxt.ScopedBlock != mx.ParentNode && mx.ParentNode != null))
ctxt.PushNewScope(mx.ParentNode as IBlockNode, mx);
bool hadCachedItem;
if(takeStmtCache)
{
BlockStatement stmt;
hadCachedItem = mixinStmtCache.TryGet(ctxt, mx, out stmt);
cachedContent = stmt;
}
else
{
DModule mod;
hadCachedItem = mixinDeclCache.TryGet(ctxt, mx, out mod);
cachedContent = mod;
}
if(hadCachedItem)
{
stmtsBeingAnalysed.Remove(mx);
if(pop)
ctxt.Pop();
return null;
}
var x = mx.MixinExpression;
ISemantic v = null;
try // 'try' because there is always a risk of e.g. not having something implemented or having an evaluation exception...
{
// Evaluate the mixin expression
v = Evaluation.EvaluateValue(x, ctxt);
}
catch{}
stmtsBeingAnalysed.Remove(mx);
if(pop)
ctxt.Pop();
// Ensure it's a string literal
var av = v as ArrayValue;
if(av != null && av.IsString)
return av.StringValue;
if(takeStmtCache)
mixinStmtCache.Add(ctxt, mx, null);
else
mixinDeclCache.Add(ctxt, mx, null);
return null;
}
public void GetReferences(string filename, string tok, uint line, uint idx, string expr)
{
filename = normalizePath(filename);
var ast = GetModule(filename);
if (ast == null)
{
throw new COMException("module not found", 1);
}
_request = Request.References;
_result = "__pending__";
Action dg = () =>
{
_setupEditorData();
CodeLocation loc = new CodeLocation((int)idx + 1, (int)line);
_editorData.CaretLocation = loc;
_editorData.SyntaxTree = ast as DModule;
_editorData.ModuleCode = _sources[filename];
_editorData.CaretOffset = getCodeOffset(_editorData.ModuleCode, loc);
ISyntaxRegion sr = DResolver.GetScopedCodeObject(_editorData);
LooseResolution.NodeResolutionAttempt attempt;
var rr = sr != null?LooseResolution.ResolveTypeLoosely(_editorData, sr, out attempt, true) : null;
StringBuilder refs = new StringBuilder();
if (rr != null)
{
var n = DResolver.GetResultMember(rr, true);
if (n != null)
{
var ctxt = ResolutionContext.Create(_editorData, true);
if (n.ContainsAttribute(DTokens.Private) || ((n is DVariable) && (n as DVariable).IsLocal))
{
GetReferencesInModule(ast, refs, n, ctxt);
}
else
{
foreach (var basePath in _imports.Split(nlSeparator, StringSplitOptions.RemoveEmptyEntries))
{
foreach (var mod in GlobalParseCache.EnumModulesRecursively(basePath))
{
GetReferencesInModule(mod, refs, n, ctxt);
}
}
}
}
//var res = TypeReferenceFinder.Scan(_editorData, System.Threading.CancellationToken.None, null);
}
if (!_editorData.CancelToken.IsCancellationRequested && _request == Request.References)
{
_result = refs.ToString();
}
};
}
public AssocArrayType(AbstractType ValueType, AbstractType KeyType, ISyntaxRegion td)
: base(ValueType, td)
{
if (ValueType != null)
{
ValueType.NonStaticAccess = true;
}
this.KeyType = KeyType;
}
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td,
ReadOnlyCollection <TemplateParameterSymbol> deducedTypes = null)
: base(member, memberType, deducedTypes, td)
{
if (memberType != null)
{
memberType.NonStaticAccess = true;
}
}
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td,
IEnumerable <TemplateParameterSymbol> deducedTypes)
: base(member, memberType, deducedTypes, td)
{
if (memberType != null)
{
memberType.NonStaticAccess = true;
}
}
void _th(object pcl_shared)
{
var pcl = (ParseCacheList)pcl_shared;
var ctxt = new ResolverContextStack(pcl, new ResolverContext {
ScopedBlock = ast
});
// Make it as most performing as possible by avoiding unnecessary base types.
// Aliases should be analyzed deeper though.
ctxt.CurrentContext.ContextDependentOptions |=
ResolutionOptions.StopAfterFirstOverloads |
ResolutionOptions.DontResolveBaseTypes | //TODO: Exactly find out which option can be enabled here. Resolving variables' types is needed sometimes - but only, when highlighting a variable reference is wanted explicitly.
ResolutionOptions.NoTemplateParameterDeduction |
ResolutionOptions.ReturnMethodReferencesOnly;
ISyntaxRegion sr = null;
int i = 0;
while (curQueueOffset < queueCount)
{
// Avoid race condition runtime errors
lock (_lockObject)
{
i = curQueueOffset;
curQueueOffset++;
}
// Resolve gotten syntax object
sr = q[i];
var sb = ctxt.CurrentContext.ScopedBlock;
ctxt.CurrentContext.ScopedBlock = DResolver.SearchBlockAt(
sb == null || sr.Location <sb.BlockStartLocation || sr.EndLocation> sb.EndLocation ? ast : sb,
sr.Location,
out ctxt.CurrentContext.ScopedStatement);
if (sr is PostfixExpression_Access)
{
HandleAccessExpressions((PostfixExpression_Access)sr, ctxt);
}
else
{
AbstractType t = null;
if (sr is IExpression)
{
t = DResolver.StripAliasSymbol(Evaluation.EvaluateType((IExpression)sr, ctxt));
}
else if (sr is ITypeDeclaration)
{
t = DResolver.StripAliasSymbol(TypeDeclarationResolver.ResolveSingle((ITypeDeclaration)sr, ctxt));
}
// Enter into the result list
HandleResult(sr, t);
}
}
}
public TemplateParameterSymbol(ITemplateParameter tp,
ISemantic representedTypeOrValue,
ISyntaxRegion originalParameterIdentifier = null,
DNode parentNode = null)
: base(new TemplateParameterNode(tp) { Parent = parentNode },
AbstractType.Get(representedTypeOrValue), originalParameterIdentifier ?? tp)
{
this.Parameter = tp;
this.ParameterValue = representedTypeOrValue as ISymbolValue;
}
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;
}
void AddResult(ISyntaxRegion sr, byte type)
{
Dictionary <ISyntaxRegion, byte> l;
if (!Matches.TryGetValue(sr.Location.Line, out l))
{
Matches[sr.Location.Line] = l = new Dictionary <ISyntaxRegion, byte>();
}
l[sr] = type;
}
public static string ExtractId(ISyntaxRegion o)
{
if (o is IdentifierDeclaration)
return ((IdentifierDeclaration)o).Id;
else if (o is IdentifierExpression && ((IdentifierExpression)o).IsIdentifier)
return (string)((IdentifierExpression)o).Value;
else if (o is PostfixExpression_Access)
return ExtractId(((PostfixExpression_Access)o).AccessExpression);
else if (o is TemplateInstanceExpression)
return ((TemplateInstanceExpression)o).TemplateIdentifier.Id;
else if (o is NewExpression)
return ExtractId(((NewExpression)o).Type);
return null;
}
protected override void Handle(ISyntaxRegion o)
{
if (o is IdentifierDeclaration || o is TemplateInstanceExpression)
{
if (DoPrimaryIdCheck(ExtractId(o)))
result.TypeMatches.Add(o);
}
/* Though type resolution is very fast now it's still kinda slow - 300 ms for all expressions in std.stdio
else if (o is IdentifierExpression)
{
if (DoPrimaryIdCheck((string)((IdentifierExpression)o).Value))
q.Add(o);
}
else if (o is PostfixExpression_Access)
q.AddRange(DoPrimaryIdCheck((PostfixExpression_Access)o));*/
}
public TemplateParameterSymbol(TemplateParameter tpn, ISemantic typeOrValue, ISyntaxRegion paramIdentifier = null)
: base(tpn != null ? tpn.Representation : null, AbstractType.Get(typeOrValue), paramIdentifier)
{
this.Parameter = tpn;
this.ParameterValue = typeOrValue as ISymbolValue;
}
public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td,
AbstractType baseType = null, InterfaceType[] baseInterfaces = null,
ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null)
: base(dc, baseType, deducedTypes, td)
{
this.BaseInterfaces = baseInterfaces;
}
public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td,
AbstractType baseType, InterfaceType[] baseInterfaces,
IEnumerable<TemplateParameterSymbol> deducedTypes)
: this(dc,td, baseType,baseInterfaces,
deducedTypes != null ? new ReadOnlyCollection<TemplateParameterSymbol>(deducedTypes.ToArray()) : null)
{
}
public PointerType(AbstractType Base, ISyntaxRegion td)
: base(Base, td)
{
}
public PrimitiveType(byte TypeToken, byte Modifier, ISyntaxRegion td)
: base(td)
{
this.TypeToken = TypeToken;
this.modifier = Modifier;
}
public UnionType(DClassLike dc, ISyntaxRegion td, IEnumerable<TemplateParameterSymbol> deducedTypes = null)
: base(dc, td, null, null, deducedTypes)
{
}
public DTuple(ISyntaxRegion td,IEnumerable<ISemantic> items)
: base(td)
{
if (items is ISemantic[])
Items = (ISemantic[])items;
else if (items != null)
Items = items.ToArray();
}
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td,
ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null)
: base(member, memberType, deducedTypes, td)
{
}
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td,
IEnumerable<TemplateParameterSymbol> deducedTypes)
: base(member, memberType, deducedTypes, td)
{
}
public InterfaceType(DClassLike dc, ISyntaxRegion td,
InterfaceType[] baseInterfaces=null,
IEnumerable<TemplateParameterSymbol> deducedTypes = null)
: base(dc, td, null, baseInterfaces, deducedTypes)
{
}
public InterfaceType(DClassLike dc, ISyntaxRegion td,
InterfaceType[] baseInterfaces,
ReadOnlyCollection<TemplateParameterSymbol> deducedTypes)
: base(dc, td, null, baseInterfaces, deducedTypes)
{
}
public EponymousTemplateType(EponymousTemplate ep,
ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null, ISyntaxRegion td = null)
: base(ep, null, deducedTypes, td)
{
}
public EnumType(DEnum Enum, ISyntaxRegion td)
: base(Enum, new PrimitiveType(DTokens.Int, 0), null, td)
{
}
public EnumType(DEnum Enum, AbstractType BaseType, ISyntaxRegion td)
: base(Enum, BaseType, null, td)
{
}
public TemplateType(DClassLike dc, ISyntaxRegion td, IEnumerable<TemplateParameterSymbol> inheritedTypeParams = null)
: base(dc, td, null, null, inheritedTypeParams)
{
}
public DerivedDataType(AbstractType Base, ISyntaxRegion td)
: base(td)
{
this.Base = Base;
}
public TemplateType(DClassLike dc, ISyntaxRegion td, ReadOnlyCollection<TemplateParameterSymbol> inheritedTypeParams = null)
: base(dc, td, null, null, inheritedTypeParams)
{
}
public PackageSymbol(ModulePackage pack,ISyntaxRegion td)
: base(td)
{
this.Package = pack;
}
public ModuleSymbol(DModule mod, ISyntaxRegion td, PackageSymbol packageBase = null)
: base(mod, packageBase, (IEnumerable<TemplateParameterSymbol>)null, td)
{
}
public DSymbol(DNode Node, AbstractType BaseType, IEnumerable<TemplateParameterSymbol> deducedTypes, ISyntaxRegion td)
: base(BaseType, td)
{
if(deducedTypes!=null)
this.DeducedTypes = new ReadOnlyCollection<TemplateParameterSymbol>(deducedTypes.ToArray());
if (Node == null)
throw new ArgumentNullException ("Node");
this.definition = new WeakReference(Node);
NameHash = Node.NameHash;
}
