mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.4.0.167

Browse Source 
Former-commit-id: 5624ac747d633e885131e8349322922b6a59baaa
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2017-08-21 15:34:15 +00:00
parent e49d6f06c0
commit 536cd135cc
12856 changed files with 563812 additions and 223249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
mcs/mcs/anonymous.cs
View File

@@ -1652,9 +1652,10 @@ namespace Mono.CSharp {
fc.TryFinally = prev_tf;
}
public override void MarkReachable (Reachability rc)
public override Reachability MarkReachable (Reachability rc)
{
block.MarkReachable (rc);
return rc;
}
public void SetHasThisAccess ()

28
mcs/mcs/argument.cs
View File

@@ -651,13 +651,35 @@ namespace Mono.CSharp
//
// Returns dynamic when at least one argument is of dynamic type
//
public void Resolve (ResolveContext ec, out bool dynamic)
public void Resolve (ResolveContext rc, out bool dynamic)
{
dynamic = false;
List<LocalVariable> var_locals = null;
foreach (Argument a in args) {
a.Resolve (ec);
if (a.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic && !a.IsByRef)
a.Resolve (rc);
if (a.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic && !a.IsByRef) {
dynamic = true;
continue;
}
if (a.Type == InternalType.VarOutType) {
var de = a.Expr as DeclarationExpression;
if (de != null) {
if (var_locals == null)
var_locals = new List<LocalVariable> ();
var_locals.Add (de.Variable);
continue;
}
var lvr = a.Expr as LocalVariableReference;
if (lvr != null && var_locals != null && var_locals.Contains (lvr.local_info)) {
rc.Report.Error (8196, lvr.Location, "Reference to an implicitly typed out variable `{0}' is not permitted in the same argument list", lvr.Name);
lvr.Type = InternalType.ErrorType;
}
}
}
}

6
mcs/mcs/assign.cs
View File

@@ -503,11 +503,9 @@ namespace Mono.CSharp {
}
}
public override void MarkReachable (Reachability rc)
public override Reachability MarkReachable (Reachability rc)
{
var es = source as ExpressionStatement;
if (es != null)
es.MarkReachable (rc);
return source.MarkReachable (rc);
}
}

8
mcs/mcs/async.cs
View File

@@ -127,10 +127,9 @@ namespace Mono.CSharp
stmt.EmitStatement (ec);
}
public override void MarkReachable (Reachability rc)
public override Reachability MarkReachable (Reachability rc)
{
base.MarkReachable (rc);
stmt.MarkReachable (rc);
return stmt.MarkReachable (rc);
}
public override object Accept (StructuralVisitor visitor)
@@ -514,11 +513,12 @@ namespace Mono.CSharp
ec.Emit (OpCodes.Ret);
}
public override void MarkReachable (Reachability rc)
public override Reachability MarkReachable (Reachability rc)
{
//
// Reachability has been done in AsyncInitializerStatement
//
return rc;
}
}

2
mcs/mcs/class.cs.REMOVED.git-id
View File

@@ -1 +1 @@
2f2fe4580b400dfc74c80bd59366ceeeada97f71
ee417ec7ad5d2e297019767f451d0f61dde6f3e9

13
mcs/mcs/context.cs
View File

@@ -22,7 +22,8 @@ namespace Mono.CSharp
{
Normal = 0,
Probing = 1,
IgnoreAccessibility = 2
IgnoreAccessibility = 2,
IgnoreStaticUsing = 1 << 10
}
//
@@ -112,6 +113,9 @@ namespace Mono.CSharp
if (rc.HasSet (ResolveContext.Options.BaseInitializer))
flags |= ResolveContext.Options.BaseInitializer;
if (rc.HasSet (ResolveContext.Options.QueryClauseScope))
flags |= ResolveContext.Options.QueryClauseScope;
}
public ExceptionStatement CurrentTryBlock { get; set; }
@@ -195,6 +199,8 @@ namespace Mono.CSharp
NameOfScope = 1 << 17,
QueryClauseScope = 1 << 18,
///
/// Indicates the current context is in probing mode, no errors are reported.
///
@@ -559,6 +565,11 @@ namespace Mono.CSharp
variable.SetAssigned (DefiniteAssignment, generatedAssignment);
}
public void SetVariableAssigned (VariableInfo variable, DefiniteAssignmentBitSet da)
{
variable.SetAssigned (da, false);
}
public void SetStructFieldAssigned (VariableInfo variable, string name)
{
variable.SetStructFieldAssigned (DefiniteAssignment, name);

9
mcs/mcs/convert.cs
View File

@@ -744,6 +744,9 @@ namespace Mono.CSharp {
if (expr_type == target_type)
return true;
if (expr_type == InternalType.ThrowExpr)
return target_type.Kind != MemberKind.InternalCompilerType;
if (target_type.IsNullableType)
return ImplicitNulableConversion (null, expr, target_type) != null;
@@ -1370,7 +1373,7 @@ namespace Mono.CSharp {
Expression e;
if (expr_type == target_type) {
if (expr_type != InternalType.NullLiteral && expr_type != InternalType.AnonymousMethod)
if (expr_type != InternalType.NullLiteral && expr_type != InternalType.AnonymousMethod && expr_type != InternalType.ThrowExpr)
return expr;
return null;
}
@@ -1396,6 +1399,10 @@ namespace Mono.CSharp {
return null;
}
if (expr_type == InternalType.ThrowExpr) {
return target_type.Kind == MemberKind.InternalCompilerType ? null : EmptyCast.Create (expr, target_type);
}
if (target_type.IsNullableType)
return ImplicitNulableConversion (ec, expr, target_type);

2
mcs/mcs/cs-parser.jay.REMOVED.git-id
View File

@@ -1 +1 @@
91e6a23b1406f17bcc0ff188c1161ba949f1a98d
2df53e916640209092711ab75dee2489d0e8f64d

17
mcs/mcs/cs-tokenizer.cs
View File

@@ -893,6 +893,16 @@ namespace Mono.CSharp
if (parsing_block == 0)
res = -1;
break;
case Token.THROW:
switch (current_token) {
case Token.ARROW:
case Token.OP_COALESCING:
case Token.INTERR:
res = Token.THROW_EXPR;
break;
}
break;
}
@@ -1267,7 +1277,8 @@ namespace Mono.CSharp
else if (the_token == Token.INTERR_NULLABLE || the_token == Token.STAR)
goto again;
else if (the_token == Token.OP_GENERICS_LT) {
if (!parse_less_than (ref genericDimension))
int unused = 0;
if (!parse_less_than (ref unused))
return false;
goto again;
} else if (the_token == Token.OPEN_BRACKET) {
@@ -1314,7 +1325,8 @@ namespace Mono.CSharp
}
if (d == '.') {
return Token.INTERR_OPERATOR;
d = reader.Peek ();
return d >= '0' && d <= '9' ? Token.INTERR : Token.INTERR_OPERATOR;
}
if (d != ' ') {
@@ -1344,6 +1356,7 @@ namespace Mono.CSharp
case Token.THIS:
case Token.NEW:
case Token.INTERPOLATED_STRING:
case Token.THROW:
next_token = Token.INTERR;
break;

3
mcs/mcs/decl.cs
View File

@@ -290,7 +290,8 @@ namespace Mono.CSharp {
HasInstanceConstructor = 1 << 16,
HasUserOperators = 1 << 17,
CanBeReused = 1 << 18,
InterfacesExpanded = 1 << 19
InterfacesExpanded = 1 << 19,
HasInstanceField = 1 << 20
}
/// <summary>

90
mcs/mcs/driver.cs
View File

@@ -44,31 +44,45 @@ namespace Mono.CSharp
void tokenize_file (SourceFile sourceFile, ModuleContainer module, ParserSession session)
{
Stream input;
Stream input = null;
SeekableStreamReader reader = null;
try {
input = File.OpenRead (sourceFile.Name);
if (sourceFile.GetInputStream != null) {
reader = sourceFile.GetInputStream (sourceFile);
if (reader == null) {
throw new FileNotFoundException ("Delegate returned null", sourceFile.Name);
}
} else {
input = File.OpenRead (sourceFile.Name);
}
} catch {
Report.Error (2001, "Source file `" + sourceFile.Name + "' could not be found");
return;
}
using (input){
SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
var file = new CompilationSourceFile (module, sourceFile);
Tokenizer lexer = new Tokenizer (reader, file, session, ctx.Report);
int token, tokens = 0, errors = 0;
while ((token = lexer.token ()) != Token.EOF){
tokens++;
if (token == Token.ERROR)
errors++;
if (reader == null) {
using (input) {
reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
DoTokenize (sourceFile, module, session, reader);
}
Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
} else {
DoTokenize (sourceFile, module, session, reader);
}
return;
}
void DoTokenize (SourceFile sourceFile, ModuleContainer module, ParserSession session, SeekableStreamReader reader) {
var file = new CompilationSourceFile (module, sourceFile);
Tokenizer lexer = new Tokenizer (reader, file, session, ctx.Report);
int token, tokens = 0, errors = 0;
while ((token = lexer.token ()) != Token.EOF) {
tokens++;
if (token == Token.ERROR)
errors++;
}
Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
}
void Parse (ModuleContainer module)
@@ -129,36 +143,50 @@ namespace Mono.CSharp
public void Parse (SourceFile file, ModuleContainer module, ParserSession session, Report report)
{
Stream input;
Stream input = null;
SeekableStreamReader reader = null;
try {
input = File.OpenRead (file.Name);
if (file.GetInputStream != null) {
reader = file.GetInputStream (file);
if (reader == null) {
throw new FileNotFoundException ("Delegate returned null", file.Name);
}
} else {
input = File.OpenRead (file.Name);
}
} catch {
report.Error (2001, "Source file `{0}' could not be found", file.Name);
return;
}
// Check 'MZ' header
if (input.ReadByte () == 77 && input.ReadByte () == 90) {
if (reader == null) {
using (input) {
// Check 'MZ' header
if (input.ReadByte () == 77 && input.ReadByte () == 90) {
report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
input.Close ();
return;
report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name);
return;
}
input.Position = 0;
reader = new SeekableStreamReader (input, ctx.Settings.Encoding, session.StreamReaderBuffer);
DoParse (file, module, session, report, reader);
}
} else {
DoParse (file, module, session, report, reader);
}
}
input.Position = 0;
SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding, session.StreamReaderBuffer);
void DoParse (SourceFile file, ModuleContainer module, ParserSession session, Report report, SeekableStreamReader reader) {
Parse (reader, file, module, session, report);
if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) {
input.Position = 0;
reader.Stream.Position = 0;
var checksum = session.GetChecksumAlgorithm ();
file.SetChecksum (checksum.ComputeHash (input));
file.SetChecksum (checksum.ComputeHash (reader.Stream));
}
reader.Dispose ();
input.Close ();
}
public static void Parse (SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report)

2
mcs/mcs/dynamic.cs
View File

@@ -282,7 +282,7 @@ namespace Mono.CSharp
foreach (var arg in arguments) {
if (arg.Type == InternalType.VarOutType) {
// Should be special error message about dynamic dispatch
rc.Report.Error (8047, arg.Expr.Location, "Declaration expression cannot be used in this context");
rc.Report.Error (8197, arg.Expr.Location, "Cannot infer the type of implicitly-typed out variable `{0}'", ((DeclarationExpression) arg.Expr).Variable.Name);
}
}

2
mcs/mcs/ecore.cs.REMOVED.git-id
View File

@@ -1 +1 @@
d2a1b7e95dad11d133df17ce8bafb86896bc3567
73e50c4068f62902fd8f04dd4062e324366dd717

6
mcs/mcs/eval.cs
View File

@@ -958,6 +958,12 @@ namespace Mono.CSharp
importer.ImportAssembly (a, module.GlobalRootNamespace);
}
}
public void ImportTypes (bool importExtensionTypes, params Type[] types) {
#if !STATIC
importer.ImportTypes (types, module.GlobalRootNamespace, importExtensionTypes);
#endif
}
}

2
mcs/mcs/expression.cs.REMOVED.git-id
View File

@@ -1 +1 @@
04ffe7570da75db253b298cb1e2c9ad4c0759a3b
da37657867ed0e59f43a1d9eefdd010e977e9ae8

3
mcs/mcs/generic.cs
View File

@@ -3091,7 +3091,8 @@ namespace Mono.CSharp {
// Some types cannot be used as type arguments
//
if ((bound.Type.Kind == MemberKind.Void && !voidAllowed) || bound.Type.IsPointer || bound.Type.IsSpecialRuntimeType ||
bound.Type == InternalType.MethodGroup || bound.Type == InternalType.AnonymousMethod || bound.Type == InternalType.VarOutType)
bound.Type == InternalType.MethodGroup || bound.Type == InternalType.AnonymousMethod || bound.Type == InternalType.VarOutType ||
bound.Type == InternalType.ThrowExpr)
return;
var a = bounds [index];

53
mcs/mcs/import.cs
View File

@@ -195,7 +195,7 @@ namespace Mono.CSharp
TypeSpec field_type;
try {
field_type = ImportType (fi.FieldType, new DynamicTypeReader (fi));
field_type = ImportType (fi.FieldType, new DynamicTypeReader (fi), declaringType);
//
// Private field has private type which is not fixed buffer
@@ -275,7 +275,7 @@ namespace Mono.CSharp
if (add.Modifiers != remove.Modifiers)
throw new NotImplementedException ("Different accessor modifiers " + ei.Name);
var event_type = ImportType (ei.EventHandlerType, new DynamicTypeReader (ei));
var event_type = ImportType (ei.EventHandlerType, new DynamicTypeReader (ei), declaringType);
var definition = new ImportedMemberDefinition (ei, event_type, this);
return new EventSpec (declaringType, definition, event_type, add.Modifiers, add, remove);
}
@@ -346,7 +346,7 @@ namespace Mono.CSharp
if (type.HasElementType) {
var element = type.GetElementType ();
++dtype.Position;
spec = ImportType (element, dtype);
spec = ImportType (element, dtype, null);
if (!type.IsArray) {
throw new NotImplementedException ("Unknown element type " + type.ToString ());
@@ -414,6 +414,9 @@ namespace Mono.CSharp
kind = MemberKind.Constructor;
returnType = module.Compiler.BuiltinTypes.Void;
} else {
var mi = (MethodInfo)mb;
returnType = ImportType (mi.ReturnType, new DynamicTypeReader (mi.ReturnParameter), declaringType);
//
// Detect operators and destructors
//
@@ -427,7 +430,7 @@ namespace Mono.CSharp
kind = MemberKind.Operator;
}
}
} else if (parameters.IsEmpty && name == Destructor.MetadataName) {
} else if (parameters.IsEmpty && name == Destructor.MetadataName && returnType.Kind == MemberKind.Void) {
kind = MemberKind.Destructor;
if (declaringType.BuiltinType == BuiltinTypeSpec.Type.Object) {
mod &= ~Modifiers.OVERRIDE;
@@ -436,9 +439,6 @@ namespace Mono.CSharp
}
}
var mi = (MethodInfo) mb;
returnType = ImportType (mi.ReturnType, new DynamicTypeReader (mi.ReturnParameter));
// Cannot set to OVERRIDE without full hierarchy checks
// this flag indicates that the method could be override
// but further validation is needed
@@ -545,13 +545,13 @@ namespace Mono.CSharp
// Strip reference wrapping
//
var el = p.ParameterType.GetElementType ();
types[i] = ImportType (el, new DynamicTypeReader (p)); // TODO: 1-based positio to be csc compatible
types[i] = ImportType (el, new DynamicTypeReader (p), parent); // TODO: 1-based positio to be csc compatible
} else if (i == 0 && method.IsStatic && (parent.Modifiers & Modifiers.METHOD_EXTENSION) != 0 &&
HasAttribute (CustomAttributeData.GetCustomAttributes (method), "ExtensionAttribute", CompilerServicesNamespace)) {
mod = Parameter.Modifier.This;
types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p));
types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p), parent);
} else {
types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p));
types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p), parent);
if (i >= pi.Length - 2 && types[i] is ArrayContainer) {
if (HasAttribute (CustomAttributeData.GetCustomAttributes (p), "ParamArrayAttribute", "System")) {
@@ -645,14 +645,7 @@ namespace Mono.CSharp
if (set_param_count == 0) {
set_based_param = ParametersCompiled.EmptyReadOnlyParameters;
} else {
//
// Create indexer parameters based on setter method parameters (the last parameter has to be removed)
//
var data = new IParameterData[set_param_count];
var types = new TypeSpec[set_param_count];
Array.Copy (set.Parameters.FixedParameters, data, set_param_count);
Array.Copy (set.Parameters.Types, types, set_param_count);
set_based_param = new ParametersImported (data, types, set.Parameters.HasParams);
set_based_param = IndexerSpec.CreateParametersFromSetter (set, set_param_count);
}
mod = set.Modifiers;
@@ -1092,7 +1085,7 @@ namespace Mono.CSharp
}
}
protected void ImportTypes (MetaType[] types, Namespace targetNamespace, bool importExtensionTypes)
public void ImportTypes (MetaType[] types, Namespace targetNamespace, bool importExtensionTypes)
{
Namespace ns = targetNamespace;
string prev_namespace = null;
@@ -1199,15 +1192,15 @@ namespace Mono.CSharp
public TypeSpec ImportType (MetaType type)
{
return ImportType (type, new DynamicTypeReader (type));
return ImportType (type, new DynamicTypeReader (type), null);
}
TypeSpec ImportType (MetaType type, DynamicTypeReader dtype)
TypeSpec ImportType (MetaType type, DynamicTypeReader dtype, TypeSpec currentType)
{
if (type.HasElementType) {
var element = type.GetElementType ();
++dtype.Position;
var spec = ImportType (element, dtype);
var spec = ImportType (element, dtype, currentType);
if (type.IsArray)
return ArrayContainer.MakeType (module, spec, type.GetArrayRank ());
@@ -1223,11 +1216,19 @@ namespace Mono.CSharp
if (compiled_types.TryGetValue (type, out compiled_type)) {
if (compiled_type.BuiltinType == BuiltinTypeSpec.Type.Object && dtype.IsDynamicObject ())
return module.Compiler.BuiltinTypes.Dynamic;
return compiled_type;
} else {
compiled_type = CreateType (type, dtype, true);
}
return CreateType (type, dtype, true);
if (currentType == compiled_type && currentType?.IsGeneric == true) {
//
// Inflates current type to match behaviour of TypeDefinition::CurrentType used by compiled types
//
var targs = compiled_type.MemberDefinition.TypeParameters;
compiled_type = compiled_type.MakeGenericType (module, targs);
}
return compiled_type;
}
static bool IsMissingType (MetaType type)
@@ -1706,7 +1707,7 @@ namespace Mono.CSharp
token = null;
foreach (var internals in internals_visible_to) {
if (internals.Name != assembly.Name)
if (!String.Equals(internals.Name, assembly.Name, StringComparison.OrdinalIgnoreCase))
continue;
if (token == null && assembly is AssemblyDefinition) {

3
mcs/mcs/iterators.cs
View File

@@ -161,7 +161,6 @@ namespace Mono.CSharp
protected override void CloneTo (CloneContext clonectx, Statement target)
{
throw new NotSupportedException ();
}
protected override bool DoResolve (BlockContext bc)
@@ -1220,7 +1219,7 @@ namespace Mono.CSharp
}
if ((modifiers & Modifiers.UNSAFE) != 0) {
parent.Compiler.Report.Error (1629, method.Location, "Unsafe code may not appear in iterators");
Expression.UnsafeInsideIteratorError (parent.Compiler.Report, method.Location);
}
method.Block = method.Block.ConvertToIterator (method, parent, iterator_type, is_enumerable);

7
mcs/mcs/linq.cs
View File

@@ -79,10 +79,11 @@ namespace Mono.CSharp.Linq
{
}
protected override MethodGroupExpr DoResolveOverload (ResolveContext ec)
protected override MethodGroupExpr DoResolveOverload (ResolveContext rc)
{
MethodGroupExpr rmg = mg.OverloadResolve (ec, ref arguments, this, OverloadResolver.Restrictions.None);
return rmg;
using (rc.Set (ResolveContext.Options.QueryClauseScope)) {
return mg.OverloadResolve (rc, ref arguments, this, OverloadResolver.Restrictions.None);
}
}
protected override Expression DoResolveDynamic (ResolveContext ec, Expression memberExpr)

6
mcs/mcs/location.cs
View File

@@ -59,6 +59,7 @@ namespace Mono.CSharp
public readonly string OriginalFullPathName;
public readonly int Index;
public bool AutoGenerated;
public Func<SourceFile, SeekableStreamReader> GetInputStream;
SourceFileEntry file;
byte[] algGuid, checksum;
@@ -71,6 +72,11 @@ namespace Mono.CSharp
this.OriginalFullPathName = path;
}
public SourceFile (string name, string path, int index, Func<SourceFile, SeekableStreamReader> inputStreamDelegate) : this (name, path, index)
{
this.GetInputStream = inputStreamDelegate;
}
public byte[] Checksum {
get {
return checksum;

Some files were not shown because too many files have changed in this diff Show More