public ZonnonCompilation(System.Compiler.Module targetModule, System.Compiler.CompilationUnitList compilationUnits, System.CodeDom.Compiler.CompilerParameters compilerParameters, System.Compiler.Scope globalScope) : base(targetModule, compilationUnits, compilerParameters, globalScope) { init(); EXTERNALS.clear(); wasMainModule = false; }
public override MemberList GetTypesNamespacesAndPrefixes(Scope scope, bool constructorMustBeVisible, bool listAllUnderRootNamespace) { MemberList result = new MemberList(); while (scope != null && !(scope is TypeScope || scope is NamespaceScope)) scope = scope.OuterScope; if (scope == null) return result; TypeNode currentType = scope is TypeScope ? ((TypeScope)scope).Type : null; if (!(scope is NamespaceScope) && (currentType == null || currentType.DeclaringModule == null)) return result; ErrorHandler errorHandler = new ErrorHandler(new ErrorNodeList(0)); TrivialHashtable ambiguousTypes = new TrivialHashtable(); TrivialHashtable referencedLabels = new TrivialHashtable(); Looker looker = new Looker(null, errorHandler, null, ambiguousTypes, referencedLabels); looker.currentType = currentType; looker.currentModule = this.currentSymbolTable; looker.currentAssembly = looker.currentModule as AssemblyNode; result = looker.GetVisibleTypesNamespacesAndPrefixes(scope, constructorMustBeVisible, listAllUnderRootNamespace); return result; }
public Looker(Scope scope, Cci.ErrorHandler errorHandler, TrivialHashtable scopeFor) : this(scope, errorHandler, scopeFor, null, null){ this.alreadyReported[StandardIds.Var.UniqueIdKey] = true; }
public static string GetMemberName(Member m, MemberNameOptions givenOptions, Scope scope) { if (m is KeywordCompletion) return m.Name.Name; StringBuilder sb = new StringBuilder(); if (IsOptionActive(givenOptions, MemberNameOptions.Access)){ sb.Append(MemberNameBuilder.GetMemberAccessString(m)); sb.Append(' '); } if (IsOptionActive(givenOptions, MemberNameOptions.Modifiers)) { if (m.IsStatic) sb.Append("static "); } sb.Append(MemberNameBuilder.GetMemberNameRaw(m, givenOptions, scope)); return sb.ToString(); }
internal static string GetMethodName(Method method, MemberNameOptions givenOptions, Scope scope, out bool isIndexer) { string methName = null; isIndexer = false; if ( method.Template != null) methName = MemberNameBuilder.GetAtPrefixedIfRequired(method.Template.GetUnmangledNameWithoutTypeParameters(true), givenOptions); else methName = MemberNameBuilder.GetAtPrefixedIfRequired(method.GetUnmangledNameWithoutTypeParameters(true), givenOptions); if (method is InstanceInitializer) { MemberNameOptions mask = MemberNameOptions.Keywords | MemberNameOptions.TemplateInfo | MemberNameOptions.TemplateArguments | MemberNameOptions.TemplateParameters | MemberNameOptions.Namespace | MemberNameOptions.EnclosingType; methName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions & ~mask, scope); } else if (method.IsSpecialName) { if (methName.StartsWith("get_") || methName.StartsWith("set_")) { if ((method.Parameters != null && method.Parameters.Count > 0)) { // In this case enclosing type is not really an option. its part of name. methName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions, scope); if (methName == null) methName = ""; isIndexer = true; } methName = methName.Substring(4); } else if (methName.StartsWith("add_") && method.Parameters != null && method.Parameters.Count == 1) methName = methName.Substring(4); else if (methName.StartsWith("remove_") && method.Parameters != null && method.Parameters.Count == 1) methName = methName.Substring(7); else { string opName = method.Name == null ? null : (string)Cci.Checker.OperatorName[method.Name.UniqueIdKey]; if (opName != null) { // In this case Enclosing type is not really an option. its part of name. string name = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions, scope) + "." + opName; if (method.Name.UniqueIdKey == StandardIds.opExplicit.UniqueIdKey || method.Name.UniqueIdKey == StandardIds.opImplicit.UniqueIdKey) name = name + " " + MemberNameBuilder.GetMemberNameRaw(method.ReturnType, givenOptions, scope); return name; } } } else { if (method.HasCompilerGeneratedSignature) { if (method.Name.UniqueIdKey == StandardIds.Finalize.UniqueIdKey) methName = "~" + MemberNameBuilder.GetAtPrefixedIfRequired(method.DeclaringType.Name.Name, givenOptions); } } if (method.ImplementedTypes != null && method.ImplementedTypes.Count > 0 && method.ImplementedTypes[0] != null && IsOptionActive(givenOptions, MemberNameOptions.ImplementInterface)) methName = MemberNameBuilder.GetMemberNameRaw(method.ImplementedTypes[0], givenOptions, scope) + "." + methName; if (IsOptionActive(givenOptions, MemberNameOptions.EnclosingType) && !isIndexer) { string decTypeName = null; if (!IsOptionActive(givenOptions, MemberNameOptions.SmartClassName) || !MemberNameBuilder.IsAggregateVisibleIn(method.DeclaringType, scope)) decTypeName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions, scope); ; if (decTypeName != null) methName = decTypeName + "." + methName; } return methName; }
public static string GetParameterTypeName(Parameter parameter, MemberNameOptions givenOptions, Scope scope) { if (parameter == null) return ""; Reference r = parameter.Type as Reference; TypeNode typeNode = null; StringBuilder sb = new StringBuilder(); string backUpName = null; if (r != null) { if ((parameter.Flags & ParameterFlags.Out) != 0) { if ( IsOptionActive(givenOptions, MemberNameOptions.PutParameterModifiers) ) sb.Append("out "); typeNode = r.ElementType; } else { if (IsOptionActive(givenOptions, MemberNameOptions.PutParameterModifiers)) sb.Append("ref "); typeNode = r.ElementType; } } else if (parameter.GetParamArrayElementType() != null) { if (IsOptionActive(givenOptions, MemberNameOptions.PutParameterModifiers)) sb.Append("params "); typeNode = parameter.Type; } else { typeNode = parameter.Type; if (typeNode == null && parameter.TypeExpression != null) backUpName = parameter.TypeExpression.SourceContext.SourceText; } sb.Append(backUpName != null ? MemberNameBuilder.GetAtPrefixedIfRequired(backUpName, givenOptions) : GetMemberNameRaw(typeNode, givenOptions, scope)); if (IsOptionActive(givenOptions, MemberNameOptions.PutParameterName) && parameter.Name!= null) { sb.Append(' '); sb.Append(MemberNameBuilder.GetAtPrefixedIfRequired(parameter.Name.ToString(), givenOptions)); } return sb.ToString(); }
internal static bool IsAggregateVisibleIn(TypeNode typeNode, Scope scope) { if (scope == null) return false; if (typeNode == null) return true; while (scope != null && !(scope is TypeScope)) { scope = scope.OuterScope; } for (TypeScope tScope = scope as TypeScope; tScope != null; tScope = tScope.OuterScope as TypeScope) { if (tScope.Type == null) continue; if (typeNode == tScope.Type || tScope.Type.IsDerivedFrom(typeNode)) { return true; } } return false; }
internal Looker(Scope scope, ErrorHandler errorHandler, TrivialHashtable scopeFor, TypeSystem typeSystem, TrivialHashtable ambiguousTypes, // LJW: added typeSystem parameter TrivialHashtable referencedLabels, Hashtable exceptionNames) : base(scope, errorHandler, scopeFor, typeSystem, ambiguousTypes, referencedLabels) { this.exceptionNames = exceptionNames; }
public override Node CompileParseTree(Node node, Scope scope, Module targetModule, ErrorNodeList errorNodes){ TrivialHashtable ambiguousTypes = new TrivialHashtable(); TrivialHashtable referencedLabels = new TrivialHashtable(); TrivialHashtable scopeFor = new TrivialHashtable(); ErrorHandler errorHandler = new ErrorHandler(errorNodes); SpecSharpCompilation ssCompilation = new SpecSharpCompilation(); // Setting the state TypeNode thisType = null; Method currentMethod = null; BlockScope blockScope = scope as BlockScope; if (blockScope != null){ Class baseScope = blockScope; MethodScope methodScope = null; while (baseScope != null){ methodScope = baseScope.BaseClass as MethodScope; if (methodScope != null) break; baseScope = baseScope.BaseClass; } if (methodScope != null){ thisType = methodScope.ThisType; if (thisType == null && methodScope.BaseClass is TypeScope){ thisType = ((TypeScope) methodScope.BaseClass).Type; } currentMethod = methodScope.DeclaringMethod; } } //Attach scope to namespaces and types scopeFor[node.UniqueKey] = scope; Scoper scoper = new Scoper(scopeFor); scoper.currentScope = scope; node = scoper.Visit(node); //Walk IR looking up names Looker looker = new Looker(scope, errorHandler, scopeFor, ambiguousTypes, referencedLabels); // begin change by drunje (this is called from debugger only) looker.AllowPointersToManagedStructures = true; // end change by drunje if (blockScope != null) { looker.currentType = thisType; looker.currentMethod = currentMethod; } looker.currentAssembly = targetModule as AssemblyNode; looker.currentModule = targetModule; node = looker.Visit(node); //Walk IR inferring types and resolving overloads TypeSystem typeSystem = new TypeSystem(errorHandler); Resolver resolver = new Resolver(errorHandler, typeSystem); if (blockScope != null){ resolver.currentType = thisType; resolver.currentMethod = currentMethod; } resolver.currentAssembly = targetModule as AssemblyNode; resolver.currentModule = targetModule; node = resolver.Visit(node); //TODO: Need to set the state of the checker for compiling Expression, STOP using this method when the shift is complete //Walk IR checking for semantic errors and repairing it so that the next walk will work Checker checker = new Checker(ssCompilation, errorHandler, typeSystem, scopeFor, ambiguousTypes, referencedLabels); if (blockScope != null){ checker.currentType = thisType; checker.currentMethod = currentMethod; } checker.currentAssembly = targetModule as AssemblyNode; checker.currentModule = targetModule; node = checker.Visit(node); //Walk IR reducing it to nodes that have predefined mappings to MD+IL Normalizer normalizer = new Normalizer(typeSystem); if (blockScope != null){ normalizer.currentType = thisType; normalizer.currentMethod = currentMethod; normalizer.WrapToBlockExpression = false; } normalizer.currentModule = targetModule; node = normalizer.Visit(node); return node; }
protected override MemberList GetMembers(int line, int col, QualifiedIdentifier qualId, Scope scope){ this.suppressAttributeSuffix = scope is AttributeScope; return base.GetMembers(line, col, qualId, scope); }
protected override MemberList GetMembers(int line, int col, Node node, Scope scope){ KeywordCompletionList keywordList = node as KeywordCompletionList; if (keywordList != null) return new MemberList(keywordList.KeywordCompletions); else return base.GetMembers(line, col, node, scope); }
protected override MemberList GetMembers(int line, int col, AttributeNode attrNode, Scope scope) { if (attrNode == null || scope == null) return null; this.suppressAttributeSuffix = true; return base.GetMembers(line, col, attrNode, scope); }
public override void AddReleventKeywords(MemberList memberList, Node node, Scope scope, int identifierContext) { if (memberList == null) return; if (node is AttributeNode ){ LanguageService.AddAttributeContextKeywords(memberList); return; } if (node is TypeAlias) { memberList.AddList(LanguageService.GetNamespaceStartKeywords()); return; } Construct cons = node as Construct; if (cons != null){ Member lastMember = memberList.Count > 0 ? memberList[memberList.Count - 1] : null; memberList.RemoveAt(memberList.Count - 1); if (!(cons.Constructor is QualifiedIdentifier)) { lastMember = LanguageService.AddTypeKeywords(memberList, lastMember as TypeNode); } if(lastMember!= null) memberList.Add(lastMember); return; } Identifier id = node as Identifier; if (id != null) { bool lastMemberPresent = memberList.Count > 0; Member lastMember = memberList.Count > 0 ? memberList[memberList.Count - 1] : null; memberList.RemoveAt(memberList.Count - 1); lastMember = LanguageService.AddTypeKeywords(memberList, lastMember as TypeNode); if (lastMemberPresent) memberList.Add(lastMember); return; } TypeExpression tExpr = node as TypeExpression; if (tExpr != null && !(tExpr.Expression is QualifiedIdentifier)) { LanguageService.AddTypeKeywords(memberList, null); return; } if (node is NameBinding) { if (identifierContext == IdentifierContexts.ParameterContext) LanguageService.AddParameterContextKeywords(memberList); else if (scope is NamespaceScope || scope is TypeScope) { if (identifierContext == IdentifierContexts.TypeContext) LanguageService.AddTypeKeywords(memberList, null); else if(identifierContext != IdentifierContexts.EventContext) this.AddTypeMemberKeywords(memberList); } else if (identifierContext == IdentifierContexts.TypeContext && !((scope is BlockScope) && (scope.OuterScope is TypeScope))) // type but not member decl scope... LanguageService.AddTypeKeywords(memberList, null); else if (this.parsingStatement || scope is AttributeScope) this.AddStatementKeywords(memberList, scope); else if (identifierContext != IdentifierContexts.EventContext) this.AddTypeMemberKeywords(memberList); return; } if ((node == null || node is Namespace) && identifierContext == IdentifierContexts.AllContext){ if(this.parsingStatement) this.AddStatementKeywords(memberList, scope); else this.AddTypeMemberKeywords(memberList); } }
private void AddStatementKeywords(MemberList/*!*/ members, Scope scope) { foreach (KeywordCompletion keyword in LanguageService.statementKeywords) members.Add(keyword); if (this.allowSpecSharpExtensions){ members.Add(new KeywordCompletion("additive")); members.Add(new KeywordCompletion("assert")); members.Add(new KeywordCompletion("assume")); members.Add(new KeywordCompletion("ensures")); members.Add(new KeywordCompletion("expose")); members.Add(new KeywordCompletion("invariant")); members.Add(new KeywordCompletion("requires")); } while (scope != null && !(scope is MethodScope)) { scope = scope.OuterScope; } MethodScope ms = scope as MethodScope; if (ms != null && ms.DeclaringMethod != null && !ms.DeclaringMethod.IsStatic) { members.Add(new KeywordCompletion("this")); } }
public override MemberList GetNestedNamespacesAndTypes(Identifier name, Scope scope, AssemblyReferenceList assembliesToSearch){ MemberList result = new MemberList(); ErrorHandler errorHandler = new ErrorHandler(new ErrorNodeList(0)); TrivialHashtable scopeFor = new TrivialHashtable(); TrivialHashtable factoryMap = new TrivialHashtable(); TrivialHashtable ambiguousTypes = new TrivialHashtable(); TrivialHashtable referencedLabels = new TrivialHashtable(); Looker looker = new Looker(null, errorHandler, null, ambiguousTypes, referencedLabels); looker.currentModule = this.currentSymbolTable; return looker.GetNestedNamespacesAndTypes(name, scope, assembliesToSearch); }
public override Namespace VisitNamespace(Namespace nspace) { if (nspace == null) return null; Scope savedScope = this.scope; NamespaceScope ns = new NamespaceScope(); ns.AssociatedNamespace = nspace; this.scope = ns; Namespace result = base.VisitNamespace(nspace); this.scope = savedScope; return result; }
public Declarations(MemberList memberList, Cci.AuthoringHelper helper, Node node, Scope scope) : base(memberList, helper, node, scope){ }
// LJW: added typeSystem parameter internal Looker(Scope scope, Microsoft.Zing.ErrorHandler errorHandler, TrivialHashtable scopeFor, TypeSystem typeSystem) : this(scope, errorHandler, scopeFor, typeSystem, null, null, null) { }
public override string GetSignature(Member member, Scope scope) { MemberNameOptions options = MemberNameOptions.PutSignature | MemberNameOptions.PutReturnType | MemberNameOptions.PutParameterName | MemberNameOptions.PutParameterModifiers | MemberNameOptions.Keywords | MemberNameOptions.EnclosingType | MemberNameOptions.Namespace | MemberNameOptions.SmartNamespaceName | MemberNameOptions.TemplateArguments | MemberNameOptions.TemplateParameters | MemberNameOptions.AtPrefix | MemberNameOptions.PutMethodConstraints; return MemberNameBuilder.GetMemberName(member, options, scope); }
internal static bool IsNamespaceImportedByScope(Identifier nspName, Scope scope) { if (scope == null) return false; if (nspName == null) return true; while (scope != null && !(scope is NamespaceScope)) { scope = scope.OuterScope; } for (NamespaceScope nsScope = scope as NamespaceScope; nsScope != null; nsScope = nsScope.OuterScope as NamespaceScope) { Namespace ns = nsScope.AssociatedNamespace; if (ns != null) { if (ns.Name == null) continue; if (ns.Name.UniqueIdKey == nspName.UniqueIdKey) return true; UsedNamespaceList nsList = ns.UsedNamespaces; if (nsList == null || nsList.Count == 0) continue; for (int i = 0; i < nsList.Count; ++i) { if (nsList[i] == null) continue; if (nsList[i].Namespace == null) continue; if (nsList[i].Namespace.UniqueIdKey == nspName.UniqueIdKey) { return true; } } } } return false; }
public Scope(Scope outerScope) { this.OuterScope = outerScope; }
internal static string GetDelegateConstructorSignature(Method method, MemberNameOptions givenOptions, Scope scope) { DelegateNode del = method.DeclaringType as DelegateNode; if (del == null) return ""; StringBuilder sb = new StringBuilder(); sb.Append(MemberNameBuilder.GetMemberNameRaw(del, givenOptions, scope)); MemberNameOptions mask = MemberNameOptions.Keywords | MemberNameOptions.TemplateInfo | MemberNameOptions.TemplateArguments | MemberNameOptions.TemplateParameters | MemberNameOptions.Namespace | MemberNameOptions.EnclosingType; string methName = MemberNameBuilder.GetMemberNameRaw(method.DeclaringType, givenOptions & ~mask, scope); sb.Append('.'); sb.Append(methName); sb.Append('('); sb.Append(MemberNameBuilder.GetMemberNameRaw(del.ReturnType, givenOptions, scope)); sb.Append(MemberNameBuilder.GetSignatureString(del.Parameters, "(", ")", ", ", givenOptions&~MemberNameOptions.PutParameterName, scope, false)); sb.Append(") target)"); return sb.ToString(); }
public TypeScope(Scope parentScope, TypeNode/*!*/ type) { this.baseClass = parentScope; this.DeclaringModule = type.DeclaringModule; this.Type = type; if(type != null && type.PartiallyDefines != null) this.Type = type.PartiallyDefines; this.templateParameters = type.TemplateParameters; if(type != null) this.LexicalSourceExtent = type.SourceContext; }
internal static string GetSignatureString(ParameterList parameters, string startPars, string endPars, string parSep, MemberNameOptions givenOpts, Scope scope, bool addNamedParameters) { StringBuilder sb = new StringBuilder(256); sb.Append(startPars); int n = parameters == null ? 0 : parameters.Count; for (int i = 0; i < n; i++) { Parameter p = parameters[i]; sb.Append(GetParameterTypeName(p, givenOpts, scope)); if (i < n - 1) sb.Append(parSep); } if (addNamedParameters) { string namedParamters = SpecSharpErrorNode.ResourceManager.GetString("NamedParameters", CultureInfo.CurrentCulture); if ( n > 0 ){ sb.Append(parSep); sb.Append(namedParamters); }else{ sb.Append(namedParamters); } } sb.Append(endPars); return sb.ToString(); }
public BlockScope(Scope/*!*/ parentScope, Block associatedBlock) { this.AssociatedBlock = associatedBlock; if(associatedBlock != null) { associatedBlock.HasLocals = true; //TODO: set only if there really are locals associatedBlock.Scope = this; } this.baseClass = parentScope; this.DeclaringModule = parentScope.DeclaringModule; if(associatedBlock != null) this.LexicalSourceExtent = associatedBlock.SourceContext; }
internal static string GetMemberNameRaw(Member m, MemberNameOptions givenOptions, Scope scope) { TypeNode typeNode = m as TypeNode; if (typeNode != null) { if (typeNode.Name == Looker.NotFound) return ""; if (IsOptionActive(givenOptions, MemberNameOptions.ExpandNullable) && typeNode.Template == SystemTypes.GenericNullable && typeNode.TemplateArguments != null && typeNode.TemplateArguments.Count > 0) { return MemberNameBuilder.GetMemberNameRaw(typeNode.TemplateArguments[0], givenOptions, scope) + "?"; } if (IsOptionActive(givenOptions, MemberNameOptions.Keywords)) { switch (typeNode.TypeCode) { case TypeCode.Boolean: return "bool"; case TypeCode.Byte: return "byte"; case TypeCode.Char: return "char"; case TypeCode.Decimal: return "decimal"; case TypeCode.Double: return "double"; case TypeCode.Int16: return "short"; case TypeCode.Int32: return "int"; case TypeCode.Int64: return "long"; case TypeCode.SByte: return "sbyte"; case TypeCode.Single: return "float"; case TypeCode.String: return "string"; case TypeCode.UInt16: return "ushort"; case TypeCode.UInt32: return "uint"; case TypeCode.UInt64: return "ulong"; } if (typeNode == SystemTypes.Object) return "object"; if (typeNode == SystemTypes.Void) return "void"; } switch (typeNode.NodeType) { case NodeType.ArrayType: { ArrayType aType = (ArrayType)typeNode; StringBuilder sb = new StringBuilder(MemberNameBuilder.GetMemberNameRaw(aType.ElementType, givenOptions, scope)); sb.Append('['); for (int i = 0, n = aType.Rank; i < n; i++) { if (i == 0 && n > 1) sb.Append('*'); if (i < n - 1) { sb.Append(','); if (n > 1) sb.Append('*'); } } sb.Append(']'); return sb.ToString(); } case NodeType.ConstrainedType: case NodeType.DelegateNode: case NodeType.EnumNode: case NodeType.Interface: case NodeType.TypeAlias: case NodeType.Class:{ FunctionType fType = typeNode as FunctionType; if (fType != null) { return "delegate " + MemberNameBuilder.GetMemberNameRaw(fType.ReturnType, givenOptions, scope) + " " + MemberNameBuilder.GetSignatureString(fType.Parameters, "(", ")", ", ", givenOptions, scope, false); } ClosureClass cClass = typeNode as ClosureClass; if (cClass != null) { MemberList mems = cClass.Members; for (int i = 0, n = mems == null ? 0 : mems.Count; i < n; i++) { Method meth = mems[i] as Method; if (meth == null || meth is InstanceInitializer || (meth.Parameters != null && meth.Parameters.Count != 0)) continue; return MemberNameBuilder.GetMemberNameRaw(meth.ReturnType, givenOptions, scope); } } StringBuilder sb = new StringBuilder(); if (IsOptionActive(givenOptions, MemberNameOptions.Namespace) && typeNode.Namespace != null) { string prefix = typeNode.Namespace.Name + "."; if (IsOptionActive(givenOptions, MemberNameOptions.SmartNamespaceName) && MemberNameBuilder.IsNamespaceImportedByScope(typeNode.Namespace, scope)) prefix = ""; sb.Append(MemberNameBuilder.GetAtPrefixedIfRequired(prefix, givenOptions)); } if (IsOptionActive(givenOptions, MemberNameOptions.EnclosingType) && m.DeclaringType != null) { string prefix = ""; if (!IsOptionActive(givenOptions, MemberNameOptions.SmartClassName) || !MemberNameBuilder.IsAggregateVisibleIn(m.DeclaringType, scope)) prefix = MemberNameBuilder.GetMemberNameRaw(typeNode.DeclaringType, givenOptions, scope) + "."; ; sb.Append(MemberNameBuilder.GetAtPrefixedIfRequired(prefix, givenOptions)); } string typeName = MemberNameBuilder.GetAtPrefixedIfRequired(typeNode.GetUnmangledNameWithoutTypeParameters(), givenOptions); if (IsOptionActive(givenOptions, MemberNameOptions.SupressAttributeSuffix) && typeName.EndsWith("Attribute")) { typeName = MemberNameBuilder.GetAtPrefixedIfRequired(typeName.Substring(0, typeName.Length - 9), givenOptions); } sb.Append(typeName); if (typeNode.TemplateParameters != null && typeNode.TemplateParameters.Count > 0) { if (IsOptionActive(givenOptions, MemberNameOptions.TemplateInfo)) sb.Append("<>"); else if(IsOptionActive(givenOptions, MemberNameOptions.TemplateParameters)){ sb.Append('<'); int n = typeNode.TemplateParameters.Count; for (int i = 0; i < n; i++) { sb.Append(MemberNameBuilder.GetMemberNameRaw(typeNode.TemplateParameters[i], givenOptions, scope)); if (i < n - 1) sb.Append(','); } sb.Append('>'); } } else if (typeNode.Template != null && typeNode.TemplateArguments != null && typeNode.TemplateArguments.Count > 0 && IsOptionActive(givenOptions, MemberNameOptions.TemplateArguments)) { sb.Append('<'); int n = typeNode.TemplateArguments.Count; for (int i = 0; i < n; i++) { sb.Append(MemberNameBuilder.GetMemberNameRaw(typeNode.TemplateArguments[i], givenOptions | MemberNameOptions.Keywords, scope)); if (i < n - 1) sb.Append(','); } sb.Append('>'); } return sb.ToString(); } case NodeType.OptionalModifier: if (((OptionalModifier)typeNode).Modifier == SystemTypes.NonNullType) return MemberNameBuilder.GetMemberNameRaw(((OptionalModifier)typeNode).ModifiedType, givenOptions, scope) + "!"; goto case NodeType.RequiredModifier; case NodeType.RequiredModifier: return MemberNameBuilder.GetMemberNameRaw(((TypeModifier)typeNode).ModifiedType, givenOptions, scope); case NodeType.Pointer: return MemberNameBuilder.GetMemberNameRaw(((Pointer)typeNode).ElementType, givenOptions, scope) + "*"; case NodeType.Reference: return "ref " + MemberNameBuilder.GetMemberNameRaw(((Reference)typeNode).ElementType, givenOptions, scope); case NodeType.Refanytype: case NodeType.Struct: goto case NodeType.Class; case NodeType.ClassParameter: case NodeType.TypeParameter: return MemberNameBuilder.GetAtPrefixedIfRequired(typeNode.Name.ToString(), givenOptions); case NodeType.ClassExpression: case NodeType.InterfaceExpression: case NodeType.TypeExpression: case NodeType.ArrayTypeExpression: case NodeType.FlexArrayTypeExpression: case NodeType.FunctionTypeExpression: case NodeType.PointerTypeExpression: case NodeType.ReferenceTypeExpression: case NodeType.StreamTypeExpression: case NodeType.NonEmptyStreamTypeExpression: case NodeType.NonNullTypeExpression: case NodeType.NonNullableTypeExpression: case NodeType.BoxedTypeExpression: case NodeType.NullableTypeExpression: case NodeType.InvariantTypeExpression: case NodeType.TupleTypeExpression: case NodeType.TypeIntersectionExpression: case NodeType.TypeUnionExpression: return typeNode.SourceContext.SourceText; } } Method method = m as Method; if (method != null) { if (method is InstanceInitializer && method.DeclaringType is DelegateNode) return MemberNameBuilder.GetDelegateConstructorSignature(method, givenOptions, scope); StringBuilder sb = new StringBuilder(); if (IsOptionActive(givenOptions, MemberNameOptions.PutReturnType) && !(method is InstanceInitializer)) { sb.Append(MemberNameBuilder.GetMemberNameRaw(method.ReturnType, givenOptions, scope)); sb.Append(' '); } bool isIndexer; sb.Append(MemberNameBuilder.GetMethodName(method, givenOptions, scope, out isIndexer)); if (method.TemplateParameters != null && method.TemplateParameters.Count > 0) { if (IsOptionActive(givenOptions, MemberNameOptions.TemplateInfo)) sb.Append("<>"); else if (IsOptionActive(givenOptions, MemberNameOptions.TemplateParameters)) { sb.Append('<'); int n = method.TemplateParameters.Count; for (int i = 0; i < n; i++) { sb.Append(MemberNameBuilder.GetMemberNameRaw(method.TemplateParameters[i], givenOptions, scope)); if (i < n - 1) sb.Append(','); } sb.Append('>'); } } else if (method.Template != null && method.TemplateArguments != null && method.TemplateArguments.Count > 0 && IsOptionActive(givenOptions, MemberNameOptions.TemplateArguments)) { sb.Append('<'); int n = method.TemplateArguments.Count; for (int i = 0; i < n; i++) { sb.Append(MemberNameBuilder.GetMemberNameRaw(method.TemplateArguments[i], givenOptions | MemberNameOptions.Keywords, scope)); if (i < n - 1) sb.Append(','); } sb.Append('>'); } if (IsOptionActive(givenOptions, MemberNameOptions.PutSignature)) { InstanceInitializer ctor = method as InstanceInitializer; bool addNamedParameters = false; if (ctor != null) { MemberList ml = ctor.GetAttributeConstructorNamedParameters(); addNamedParameters = ml != null && ml.Count > 0; } sb.Append(MemberNameBuilder.GetSignatureString(method.Parameters, isIndexer ? "[" : "(", isIndexer ? "]" : ")", ", ", givenOptions, scope, addNamedParameters)); } if (IsOptionActive(givenOptions, MemberNameOptions.PutMethodConstraints) && method.TemplateParameters != null && method.TemplateParameters.Count > 0) { TypeNodeList templParameterList = method.TemplateParameters; int n = templParameterList.Count; for (int i = 0; i < n; i++) { TypeNode templParameter = templParameterList[i]; ITypeParameter tpar = templParameter as ITypeParameter; if (!HasConstraints(templParameter, tpar) ) continue; sb.AppendFormat(" where {0} :", templParameter.Name.Name); bool isFirst = true; switch (tpar.TypeParameterFlags & TypeParameterFlags.SpecialConstraintMask) { case TypeParameterFlags.DefaultConstructorConstraint: sb.Append(" new()"); isFirst = false; break; case TypeParameterFlags.ReferenceTypeConstraint: sb.Append(" class"); isFirst = false; break; case TypeParameterFlags.ValueTypeConstraint: sb.Append(" struct"); isFirst = false; break; } if (templParameter.BaseType != null && templParameter.BaseType != SystemTypes.Object) { if (isFirst) sb.Append(' '); else sb.Append(", "); sb.Append(MemberNameBuilder.GetMemberNameRaw(templParameterList[i].BaseType, givenOptions, scope)); isFirst = false; } if (templParameter.Interfaces != null && templParameter.Interfaces.Count > 0) { InterfaceList interfaceList = templParameter.Interfaces; int n2 = interfaceList.Count; for (int j = 0; j < n2; ++j) { if (interfaceList[i] == null) continue; if (isFirst) sb.Append(' '); else sb.Append(", "); sb.Append(MemberNameBuilder.GetMemberNameRaw(interfaceList[i], givenOptions, scope)); isFirst = false; } } } } return sb.ToString(); } Property p = m as Property; if (p != null) { StringBuilder sb = new StringBuilder(); if (IsOptionActive(givenOptions, MemberNameOptions.PutReturnType)) { sb.Append(MemberNameBuilder.GetMemberNameRaw(p.Type, givenOptions, scope)); sb.Append(' '); } string name = null; bool isIndexer = false; if (p.DeclaringType.DefaultMembers.Contains(p)) { name = MemberNameBuilder.GetMemberNameRaw(p.DeclaringType, givenOptions, scope); isIndexer = true; } else name = MemberNameBuilder.GetAtPrefixedIfRequired(p.Name.ToString(), givenOptions); if (IsOptionActive(givenOptions, MemberNameOptions.EnclosingType) && !isIndexer) { string decTypeName = null; if (!IsOptionActive(givenOptions, MemberNameOptions.SmartClassName) || !MemberNameBuilder.IsAggregateVisibleIn(p.DeclaringType, scope)) decTypeName = MemberNameBuilder.GetMemberNameRaw(p.DeclaringType, givenOptions, scope); ; if (decTypeName != null) { sb.Append(decTypeName); sb.Append("."); } } sb.Append(name); if (IsOptionActive(givenOptions, MemberNameOptions.PutSignature)) sb.Append(MemberNameBuilder.GetSignatureString(p.Parameters, isIndexer ? "[" : "(", isIndexer ? "]" : ")", ", ", givenOptions, scope, false)); return sb.ToString(); } if (m==null || m.Name == null) return " "; return MemberNameBuilder.GetAtPrefixedIfRequired(m.Name.ToString(), givenOptions); }
public AttributeScope(Scope parentScope, AttributeNode associatedAttribute) { this.AssociatedAttribute = associatedAttribute; this.baseClass = parentScope; if(associatedAttribute != null) this.LexicalSourceExtent = associatedAttribute.SourceContext; }
public NamespaceScope(Scope outerScope, Namespace associatedNamespace, Module associatedModule) : base(outerScope) { //^ base; this.AssociatedNamespace = associatedNamespace; this.AssociatedModule = associatedModule; this.DeclaringModule = associatedModule; //TODO: make this go away if(associatedNamespace != null) this.LexicalSourceExtent = associatedNamespace.SourceContext; }
public Compilation(Module targetModule, CompilationUnitList compilationUnits, System.CodeDom.Compiler.CompilerParameters compilerParameters, Scope globalScope) : base(NodeType.Compilation) { this.CompilationUnits = compilationUnits; this.TargetModule = targetModule; this.CompilerParameters = compilerParameters; this.GlobalScope = globalScope; }
public Looker(Scope scope, Cci.ErrorHandler errorHandler, TrivialHashtable scopeFor, TrivialHashtable ambiguousTypes, TrivialHashtable referencedLabels) : base(scope, errorHandler, scopeFor, new TypeSystem(new ErrorHandler(errorHandler.Errors)), ambiguousTypes, referencedLabels){ this.alreadyReported[StandardIds.Var.UniqueIdKey] = true; }
public override MemberList GetVisibleNames(Scope scope){ MemberList result = new MemberList(); if (scope == null) return result; Scope sc = scope; if (sc is MethodScope) return this.GetTypesNamespacesAndPrefixes(scope, false, false); //inside a parameter list. while (sc is BlockScope) sc = sc.OuterScope; MethodScope mscope = sc as MethodScope; while (sc != null && !(sc is TypeScope || sc is NamespaceScope)) sc = sc.OuterScope; TypeNode currentType = sc is TypeScope ? ((TypeScope)sc).Type : null; ErrorHandler errorHandler = new ErrorHandler(new ErrorNodeList(0)); TrivialHashtable ambiguousTypes = new TrivialHashtable(); TrivialHashtable referencedLabels = new TrivialHashtable(); Looker looker = new Looker(null, errorHandler, null, ambiguousTypes, referencedLabels); if (mscope != null) looker.currentMethod = mscope.DeclaringMethod; looker.currentType = currentType; looker.currentModule = this.currentSymbolTable; looker.currentAssembly = looker.currentModule as AssemblyNode; return looker.GetVisibleNames(scope); }