[OPENMP50]Add basic support for array-shaping operation.

[ABataev]

Summary

Added basic representation and parsing/sema handling of array-shaping
operations. Array shaping expression is an expression of form ([s0]..[sn])base,
where s0, ..., sn must be a positive integer, base - a pointer. This
expression is a kind of cast operation that converts pointer expression
into an array-like kind of expression.

[ABataev]

Ping

[ABataev]

Ping 2

[ABataev]

Ping 3

[jdoerfert]

clang/lib/Parse/ParseExpr.cpp

2891–2923

Out of curiosity, why do we prevent Objective C here? I doubt anyone runs it in OpenMP mode but it would be kinda cool.

clang/lib/Sema/SemaExpr.cpp

4744

Typo above.

4750

Does this trigger as well if BaseTy is a pointer type but dependent? I mean, why do we need the first check (!BaseTy->isAnyPointerType() &&)?

clang/test/OpenMP/parallel_reduction_messages.c

8

Why is there a 50 error here?

clang/test/OpenMP/task_ast_print.cpp

160

We do not complain that argc is non-constant. Is that on purpose?

[ABataev]

clang/lib/Parse/ParseExpr.cpp

2891–2923

Just used this to prevent the error messages from Objective C tests when enabled OpenMP by default to test that parsing work correctl in the corner cases. Will remove this check.

clang/lib/Sema/SemaExpr.cpp

4750

Not sure this is a real issue. If the type is not a pointer type, but the dependent, just skip all checks. All the required checks will be performed upon the instantiation.

clang/test/OpenMP/parallel_reduction_messages.c

8

Array shaping is not supported for the reductions

clang/test/OpenMP/task_ast_print.cpp

160

Yes, the standard allows the use of the non-constant values as the dimensions.

[ABataev]

Rebase + fixes

[ABataev]

Ping

[jdoerfert]

My questions are answered, as you have the clang people in the reviewer list and I was only added by my OpenMP hook, I would them to OK this. Thanks!

[ABataev]

Ping

[ABataev]

Ping 7

[rjmccall]

Okay, so these array-shaping expressions are only allowed as operands to specific OpenMP directives? That's a plausible interpretation of "The shape-operator can appear only in clauses where it is explicitly allowed" from the spec. If it were a more general l-value expression, we could handle that just fine by building the type using ConstantArrayType/VariableArrayType as appropriate; but if the language intentionally restricts it, the placeholder approach seems fine.

clang/lib/Sema/SemaExpr.cpp

4748

Just check isTypeDependent(), none of these other conditions should interfere with type-checking.

4751

I think you should perform DefaultFunctionArrayLvalueConversion here so that e.g. arrays will decay to pointers, you load pointers from l-values, and so on. If you do so, it'll handle placeholders for you.

Do you really want to allow this to operate on non-C pointer types?

4758

I think overload placeholders need to be resolved here, too. You may have copied this code from some different place that has the ability to resolve overloads later, but in this case that's not true.

4771

You don't really care about value-dependence here, just type-dependence. You can check value-dependence before doing the constant-evaluation check below.

[ABataev]

In D74144#1941971, @rjmccall wrote:

Okay, so these array-shaping expressions are only allowed as operands to specific OpenMP directives? That's a plausible interpretation of "The shape-operator can appear only in clauses where it is explicitly allowed" from the spec. If it were a more general l-value expression, we could handle that just fine by building the type using ConstantArrayType/VariableArrayType as appropriate; but if the language intentionally restricts it, the placeholder approach seems fine.

Hi John, thanks for the review!
Yes, this is not a general form of the expression, it is allowed only in a couple of clauses.
We cannot build an array type since this expression does not represent a supported array type. Sizes may be non-constant anywhere in the operation, variable array type does not support it. It requires extending of the variable array types but actually it does not worth a try, since this type is not needed at all.

clang/lib/Sema/SemaExpr.cpp

4748

Ok, will do.

4751

1. Standard clearly states that the type of the base expression must be a pointer. I don't think that we should perform implicit type casting here, like decay to pointers, etc.
2. It is just a simple form of checking that this is a pointer type. Since this expression is not allowed in other languages (and I filter it out at the parsing stage), I think it is ok to use the generic form of type checking.

4758

No, YouCompleteMe suggested the wrong function and I just missed it. Will fix it, thanks!

4771

Yes, just a double check to be realy-really sure :)

[ABataev]

clang/lib/Sema/SemaExpr.cpp

4751

Forgot to mention, that I thought about possible conversion here. But it may lead to some unpredictable results, like:

int a[3];
...([3][4][n])a...

Better to do not allow this kind of operation, I think.

[rjmccall]

We cannot build an array type since this expression does not represent a supported array type. Sizes may be non-constant anywhere in the operation, variable array type does not support it.

I don't think that's true; the element type of a C99 VAT can still be another VAT. The only restriction is that we don't allow a CAT of VATs — we require the outer array to still be represented as a VAT despite have a constant immediate bound — but that's just a representational restriction and doesn't restrict what we can express. But it doesn't matter because, as you say, we can and should use a placeholder here in order to enforce the use-restriction.

clang/lib/Sema/SemaExpr.cpp

4751

Standard clearly states that the type of the base expression must be a pointer. I don't think that we should perform implicit type casting here, like decay to pointers, etc.

The wording of the C/C++ standard is that expressions of array type decay except in certain syntactic positions. Such expressions then *do* have pointer type for this purpose. If precedent is to forbid array references, so be it, but that's not consistent with the normal language behavior.

It is just a simple form of checking that this is a pointer type. Since this expression is not allowed in other languages (and I filter it out at the parsing stage), I think it is ok to use the generic form of type checking.

If your intent is that this only applies only to C pointers, you should just check isPointerType() instead of isAnyPointerType(), which exists for the sole purpose of also including Objective-C pointers.

4751

You can still have pointers to arrays without suppressing array decay.

4771

Type-dependence implies value-dependence anyway.

[ABataev]

Rebase + fixes.

[rjmccall]

Okay, if you think that suppress array decay is the right behavior here, that's fine with me. Please check the behavior of other OpenMP implementations, though.

clang/lib/Sema/SemaExpr.cpp

4779

You do still need an isValueDependent() check here, and you should add a test that exercises it. (A sizeof(T) argument is probably good enough.)

[ABataev]

Rebase + fixes.

[rjmccall]

Thanks, LGTM.

[cchen]

@ABataev, the below test is extracted from Sollve test suite and Clang now emit:

test.c:17:35: error: subscripted value is not an array or pointer
    #pragma omp target update to( (([N][N])foo)[1:M] )
                                  ^~~~~~~~~~~~~
test.c:17:5: error: expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'
    #pragma omp target update to( (([N][N])foo)[1:M] )

This error message came from the ActOnOMPArraySectionExpr which is called inside ParsePostfixExpressionSuffix. The issue is that the base expression in ActOnOMPArraySectionExpr looks like:

ParenExpr 0x122859be0 '<OpenMP array shaping type>' lvalue
`-OMPArrayShapingExpr 0x122859b98 '<OpenMP array shaping type>' lvalue
  |-IntegerLiteral 0x122859b38 'int' 5
  |-IntegerLiteral 0x122859b58 'int' 5
  `-DeclRefExpr 0x122859b78 'int *' lvalue Var 0x1228599d0 'foo' 'int *'

which is not a base that we would expect in an array section expr. I've tried relaxing the base type check in ActOnOMPArraySectionExpr but not sure it's the way to go. (or should I just extract the DeclReExpr from ArrayShapingExpr before calling ActOnOMPArraySectionExpr?)

#define N 5
#define M 3

int main(void) {
    int tmp[N][N];
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            tmp[i][j] = N*i + j;

    int *foo = &tmp[0][0];

    // This compiles just fine
    //#pragma omp target update to( ([N][N])foo )

    // This is rejected by the compiler
    #pragma omp target update to( (([N][N])foo)[1:M] )
}

[ABataev]

In D74144#2307454, @cchen wrote:

@ABataev, the below test is extracted from Sollve test suite and Clang now emit:

test.c:17:35: error: subscripted value is not an array or pointer
    #pragma omp target update to( (([N][N])foo)[1:M] )
                                  ^~~~~~~~~~~~~
test.c:17:5: error: expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'
    #pragma omp target update to( (([N][N])foo)[1:M] )

This error message came from the ActOnOMPArraySectionExpr which is called inside ParsePostfixExpressionSuffix. The issue is that the base expression in ActOnOMPArraySectionExpr looks like:

ParenExpr 0x122859be0 '<OpenMP array shaping type>' lvalue
`-OMPArrayShapingExpr 0x122859b98 '<OpenMP array shaping type>' lvalue
  |-IntegerLiteral 0x122859b38 'int' 5
  |-IntegerLiteral 0x122859b58 'int' 5
  `-DeclRefExpr 0x122859b78 'int *' lvalue Var 0x1228599d0 'foo' 'int *'

which is not a base that we would expect in an array section expr. I've tried relaxing the base type check in ActOnOMPArraySectionExpr but not sure it's the way to go. (or should I just extract the DeclReExpr from ArrayShapingExpr before calling ActOnOMPArraySectionExpr?)

#define N 5
#define M 3

int main(void) {
    int tmp[N][N];
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            tmp[i][j] = N*i + j;

    int *foo = &tmp[0][0];

    // This compiles just fine
    //#pragma omp target update to( ([N][N])foo )

    // This is rejected by the compiler
    #pragma omp target update to( (([N][N])foo)[1:M] )
}

I don't think it is allowed by the standard.

According to the standard, The shape-operator can appear only in clauses where it is explicitly allowed.
In this case, array shaping is used as a base expression of array section (or subscript) expression, which does not meet the standard. Tje array sjaping operation is not used in clause, instead it is used as a base subexpression of another expression.

[cchen]

In D74144#2307494, @ABataev wrote:

In D74144#2307454, @cchen wrote:

@ABataev, the below test is extracted from Sollve test suite and Clang now emit:

test.c:17:35: error: subscripted value is not an array or pointer
    #pragma omp target update to( (([N][N])foo)[1:M] )
                                  ^~~~~~~~~~~~~
test.c:17:5: error: expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'
    #pragma omp target update to( (([N][N])foo)[1:M] )

This error message came from the ActOnOMPArraySectionExpr which is called inside ParsePostfixExpressionSuffix. The issue is that the base expression in ActOnOMPArraySectionExpr looks like:

ParenExpr 0x122859be0 '<OpenMP array shaping type>' lvalue
`-OMPArrayShapingExpr 0x122859b98 '<OpenMP array shaping type>' lvalue
  |-IntegerLiteral 0x122859b38 'int' 5
  |-IntegerLiteral 0x122859b58 'int' 5
  `-DeclRefExpr 0x122859b78 'int *' lvalue Var 0x1228599d0 'foo' 'int *'

which is not a base that we would expect in an array section expr. I've tried relaxing the base type check in ActOnOMPArraySectionExpr but not sure it's the way to go. (or should I just extract the DeclReExpr from ArrayShapingExpr before calling ActOnOMPArraySectionExpr?)

#define N 5
#define M 3

int main(void) {
    int tmp[N][N];
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            tmp[i][j] = N*i + j;

    int *foo = &tmp[0][0];

    // This compiles just fine
    //#pragma omp target update to( ([N][N])foo )

    // This is rejected by the compiler
    #pragma omp target update to( (([N][N])foo)[1:M] )
}

I don't think it is allowed by the standard.

According to the standard, The shape-operator can appear only in clauses where it is explicitly allowed.
In this case, array shaping is used as a base expression of array section (or subscript) expression, which does not meet the standard. Tje array sjaping operation is not used in clause, instead it is used as a base subexpression of another expression.

In OpenMP 5.0 [2.12.6, target update construct, Restrictions, C/C++, p.1] The list items that appear in the to or from clauses may use shape-operators.
Also, in the array shaping section in https://github.com/OpenMP/Examples, the example is also illustrated with the same usage:

...
S-17 // update boundary points (two columns of 2D array) on the host
S-18 // pointer is shaped to 2D array using the shape-operator
S-19 #pragma omp target update from( (([nx][ny+2])a)[0:nx][1], (([nx][ny+2])a)[0:nx][ny] )
...

[ABataev]

In D74144#2308796, @cchen wrote:

In D74144#2307494, @ABataev wrote:

In D74144#2307454, @cchen wrote:

@ABataev, the below test is extracted from Sollve test suite and Clang now emit:

test.c:17:35: error: subscripted value is not an array or pointer
    #pragma omp target update to( (([N][N])foo)[1:M] )
                                  ^~~~~~~~~~~~~
test.c:17:5: error: expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'
    #pragma omp target update to( (([N][N])foo)[1:M] )

This error message came from the ActOnOMPArraySectionExpr which is called inside ParsePostfixExpressionSuffix. The issue is that the base expression in ActOnOMPArraySectionExpr looks like:

ParenExpr 0x122859be0 '<OpenMP array shaping type>' lvalue
`-OMPArrayShapingExpr 0x122859b98 '<OpenMP array shaping type>' lvalue
  |-IntegerLiteral 0x122859b38 'int' 5
  |-IntegerLiteral 0x122859b58 'int' 5
  `-DeclRefExpr 0x122859b78 'int *' lvalue Var 0x1228599d0 'foo' 'int *'

which is not a base that we would expect in an array section expr. I've tried relaxing the base type check in ActOnOMPArraySectionExpr but not sure it's the way to go. (or should I just extract the DeclReExpr from ArrayShapingExpr before calling ActOnOMPArraySectionExpr?)

#define N 5
#define M 3

int main(void) {
    int tmp[N][N];
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            tmp[i][j] = N*i + j;

    int *foo = &tmp[0][0];

    // This compiles just fine
    //#pragma omp target update to( ([N][N])foo )

    // This is rejected by the compiler
    #pragma omp target update to( (([N][N])foo)[1:M] )
}

I don't think it is allowed by the standard.

According to the standard, The shape-operator can appear only in clauses where it is explicitly allowed.
In this case, array shaping is used as a base expression of array section (or subscript) expression, which does not meet the standard. Tje array sjaping operation is not used in clause, instead it is used as a base subexpression of another expression.

In OpenMP 5.0 [2.12.6, target update construct, Restrictions, C/C++, p.1] The list items that appear in the to or from clauses may use shape-operators.
Also, in the array shaping section in https://github.com/OpenMP/Examples, the example is also illustrated with the same usage:

...
S-17 // update boundary points (two columns of 2D array) on the host
S-18 // pointer is shaped to 2D array using the shape-operator
S-19 #pragma omp target update from( (([nx][ny+2])a)[0:nx][1], (([nx][ny+2])a)[0:nx][ny] )
...

Then just need to fix it, if examples document has this example.

[estewart08]

In D74144#2308856, @ABataev wrote:

In D74144#2308796, @cchen wrote:

In D74144#2307494, @ABataev wrote:

In D74144#2307454, @cchen wrote:

@ABataev, the below test is extracted from Sollve test suite and Clang now emit:

test.c:17:35: error: subscripted value is not an array or pointer
    #pragma omp target update to( (([N][N])foo)[1:M] )
                                  ^~~~~~~~~~~~~
test.c:17:5: error: expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'
    #pragma omp target update to( (([N][N])foo)[1:M] )

This error message came from the ActOnOMPArraySectionExpr which is called inside ParsePostfixExpressionSuffix. The issue is that the base expression in ActOnOMPArraySectionExpr looks like:

ParenExpr 0x122859be0 '<OpenMP array shaping type>' lvalue
`-OMPArrayShapingExpr 0x122859b98 '<OpenMP array shaping type>' lvalue
  |-IntegerLiteral 0x122859b38 'int' 5
  |-IntegerLiteral 0x122859b58 'int' 5
  `-DeclRefExpr 0x122859b78 'int *' lvalue Var 0x1228599d0 'foo' 'int *'

which is not a base that we would expect in an array section expr. I've tried relaxing the base type check in ActOnOMPArraySectionExpr but not sure it's the way to go. (or should I just extract the DeclReExpr from ArrayShapingExpr before calling ActOnOMPArraySectionExpr?)

#define N 5
#define M 3

int main(void) {
    int tmp[N][N];
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
            tmp[i][j] = N*i + j;

    int *foo = &tmp[0][0];

    // This compiles just fine
    //#pragma omp target update to( ([N][N])foo )

    // This is rejected by the compiler
    #pragma omp target update to( (([N][N])foo)[1:M] )
}

I don't think it is allowed by the standard.

According to the standard, The shape-operator can appear only in clauses where it is explicitly allowed.
In this case, array shaping is used as a base expression of array section (or subscript) expression, which does not meet the standard. Tje array sjaping operation is not used in clause, instead it is used as a base subexpression of another expression.

In OpenMP 5.0 [2.12.6, target update construct, Restrictions, C/C++, p.1] The list items that appear in the to or from clauses may use shape-operators.
Also, in the array shaping section in https://github.com/OpenMP/Examples, the example is also illustrated with the same usage:

...
S-17 // update boundary points (two columns of 2D array) on the host
S-18 // pointer is shaped to 2D array using the shape-operator
S-19 #pragma omp target update from( (([nx][ny+2])a)[0:nx][1], (([nx][ny+2])a)[0:nx][ny] )
...

Then just need to fix it, if examples document has this example.

Was this ever followed up on and fixed?

clang/include/clang-c/Index.h

enum CXCursorKind {
    * A declaration whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed declarations have the same operations as any other kind
    * of declaration; one can extract their location information,
    * spelling, find their definitions, etc. However, the specific kind
    * of the declaration is not reported.
    */
   CXCursor_UnexposedDecl                 = 1,
   /** A C or C++ struct. */
   CXCursor_StructDecl                    = 2,
   /** A C or C++ union. */
   CXCursor_UnionDecl                     = 3,
   /** A C++ class. */
   CXCursor_ClassDecl                     = 4,
   /** An enumeration. */
   CXCursor_EnumDecl                      = 5,
   /**
    * A field (in C) or non-static data member (in C++) in a
    * struct, union, or C++ class.
    */
   CXCursor_FieldDecl                     = 6,
   /** An enumerator constant. */
   CXCursor_EnumConstantDecl              = 7,
   /** A function. */
   CXCursor_FunctionDecl                  = 8,
   /** A variable. */
   CXCursor_VarDecl                       = 9,
   /** A function or method parameter. */
   CXCursor_ParmDecl                      = 10,
   /** An Objective-C \@interface. */
   CXCursor_ObjCInterfaceDecl             = 11,
   /** An Objective-C \@interface for a category. */
   CXCursor_ObjCCategoryDecl              = 12,
   /** An Objective-C \@protocol declaration. */
   CXCursor_ObjCProtocolDecl              = 13,
   /** An Objective-C \@property declaration. */
   CXCursor_ObjCPropertyDecl              = 14,
   /** An Objective-C instance variable. */
   CXCursor_ObjCIvarDecl                  = 15,
   /** An Objective-C instance method. */
   CXCursor_ObjCInstanceMethodDecl        = 16,
   /** An Objective-C class method. */
   CXCursor_ObjCClassMethodDecl           = 17,
   /** An Objective-C \@implementation. */
   CXCursor_ObjCImplementationDecl        = 18,
   /** An Objective-C \@implementation for a category. */
   CXCursor_ObjCCategoryImplDecl          = 19,
   /** A typedef. */
   CXCursor_TypedefDecl                   = 20,
   /** A C++ class method. */
   CXCursor_CXXMethod                     = 21,
   /** A C++ namespace. */
   CXCursor_Namespace                     = 22,
   /** A linkage specification, e.g. 'extern "C"'. */
   CXCursor_LinkageSpec                   = 23,
   /** A C++ constructor. */
   CXCursor_Constructor                   = 24,
   /** A C++ destructor. */
   CXCursor_Destructor                    = 25,
   /** A C++ conversion function. */
   CXCursor_ConversionFunction            = 26,
   /** A C++ template type parameter. */
   CXCursor_TemplateTypeParameter         = 27,
   /** A C++ non-type template parameter. */
   CXCursor_NonTypeTemplateParameter      = 28,
   /** A C++ template template parameter. */
   CXCursor_TemplateTemplateParameter     = 29,
   /** A C++ function template. */
   CXCursor_FunctionTemplate              = 30,
   /** A C++ class template. */
   CXCursor_ClassTemplate                 = 31,
   /** A C++ class template partial specialization. */
   CXCursor_ClassTemplatePartialSpecialization = 32,
   /** A C++ namespace alias declaration. */
   CXCursor_NamespaceAlias                = 33,
   /** A C++ using directive. */
   CXCursor_UsingDirective                = 34,
   /** A C++ using declaration. */
   CXCursor_UsingDeclaration              = 35,
   /** A C++ alias declaration */
   CXCursor_TypeAliasDecl                 = 36,
   /** An Objective-C \@synthesize definition. */
   CXCursor_ObjCSynthesizeDecl            = 37,
   /** An Objective-C \@dynamic definition. */
   CXCursor_ObjCDynamicDecl               = 38,
   /** An access specifier. */
   CXCursor_CXXAccessSpecifier            = 39,
 
   CXCursor_FirstDecl                     = CXCursor_UnexposedDecl,
   CXCursor_LastDecl                      = CXCursor_CXXAccessSpecifier,
 
   /* References */
   CXCursor_FirstRef                      = 40, /* Decl references */
   CXCursor_ObjCSuperClassRef             = 40,
   CXCursor_ObjCProtocolRef               = 41,
   CXCursor_ObjCClassRef                  = 42,
   /**
    * A reference to a type declaration.
    *
    * A type reference occurs anywhere where a type is named but not
    * declared. For example, given:
    *
    * \code
    * typedef unsigned size_type;
    * size_type size;
    * \endcode
    *
    * The typedef is a declaration of size_type (CXCursor_TypedefDecl),
    * while the type of the variable "size" is referenced. The cursor
    * referenced by the type of size is the typedef for size_type.
    */
   CXCursor_TypeRef                       = 43,
   CXCursor_CXXBaseSpecifier              = 44,
   /**
    * A reference to a class template, function template, template
    * template parameter, or class template partial specialization.
    */
   CXCursor_TemplateRef                   = 45,
   /**
    * A reference to a namespace or namespace alias.
    */
   CXCursor_NamespaceRef                  = 46,
   /**
    * A reference to a member of a struct, union, or class that occurs in
    * some non-expression context, e.g., a designated initializer.
    */
   CXCursor_MemberRef                     = 47,
   /**
    * A reference to a labeled statement.
    *
    * This cursor kind is used to describe the jump to "start_over" in the
    * goto statement in the following example:
    *
    * \code
    *   start_over:
    *     ++counter;
    *
    *     goto start_over;
    * \endcode
    *
    * A label reference cursor refers to a label statement.
    */
   CXCursor_LabelRef                      = 48,
 
   /**
    * A reference to a set of overloaded functions or function templates
    * that has not yet been resolved to a specific function or function template.
    *
    * An overloaded declaration reference cursor occurs in C++ templates where
    * a dependent name refers to a function. For example:
    *
enum CXCursorKind {
    * instantiation time, "swap" may also refer to other functions found via
    * argument-dependent lookup (e.g., the "swap" function at the end of the
    * example).
    *
    * The functions \c clang_getNumOverloadedDecls() and
    * \c clang_getOverloadedDecl() can be used to retrieve the definitions
    * referenced by this cursor.
    */
   CXCursor_OverloadedDeclRef             = 49,
 
   /**
    * A reference to a variable that occurs in some non-expression
    * context, e.g., a C++ lambda capture list.
    */
   CXCursor_VariableRef                   = 50,
 
   CXCursor_LastRef                       = CXCursor_VariableRef,
 
   /* Error conditions */
   CXCursor_FirstInvalid                  = 70,
   CXCursor_InvalidFile                   = 70,
   CXCursor_NoDeclFound                   = 71,
   CXCursor_NotImplemented                = 72,
   CXCursor_InvalidCode                   = 73,
   CXCursor_LastInvalid                   = CXCursor_InvalidCode,
 
   /* Expressions */
   CXCursor_FirstExpr                     = 100,
 
   /**
    * An expression whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed expressions have the same operations as any other kind
    * of expression; one can extract their location information,
    * spelling, children, etc. However, the specific kind of the
    * expression is not reported.
    */
   CXCursor_UnexposedExpr                 = 100,
 
   /**
    * An expression that refers to some value declaration, such
    * as a function, variable, or enumerator.
    */
   CXCursor_DeclRefExpr                   = 101,
 
   /**
    * An expression that refers to a member of a struct, union,
    * class, Objective-C class, etc.
    */
   CXCursor_MemberRefExpr                 = 102,
 
   /** An expression that calls a function. */
   CXCursor_CallExpr                      = 103,
 
   /** An expression that sends a message to an Objective-C
    object or class. */
   CXCursor_ObjCMessageExpr               = 104,
 
   /** An expression that represents a block literal. */
   CXCursor_BlockExpr                     = 105,
 
   /** An integer literal.
    */
   CXCursor_IntegerLiteral                = 106,
 
   /** A floating point number literal.
    */
   CXCursor_FloatingLiteral               = 107,
 
   /** An imaginary number literal.
    */
   CXCursor_ImaginaryLiteral              = 108,
 
   /** A string literal.
    */
   CXCursor_StringLiteral                 = 109,
 
   /** A character literal.
    */
   CXCursor_CharacterLiteral              = 110,
 
   /** A parenthesized expression, e.g. "(1)".
    *
    * This AST node is only formed if full location information is requested.
    */
   CXCursor_ParenExpr                     = 111,
 
   /** This represents the unary-expression's (except sizeof and
    * alignof).
    */
   CXCursor_UnaryOperator                 = 112,
 
   /** [C99 6.5.2.1] Array Subscripting.
    */
   CXCursor_ArraySubscriptExpr            = 113,
 
   /** A builtin binary operation expression such as "x + y" or
    * "x <= y".
    */
   CXCursor_BinaryOperator                = 114,
 
   /** Compound assignment such as "+=".
    */
   CXCursor_CompoundAssignOperator        = 115,
 
   /** The ?: ternary operator.
    */
   CXCursor_ConditionalOperator           = 116,
 
   /** An explicit cast in C (C99 6.5.4) or a C-style cast in C++
    * (C++ [expr.cast]), which uses the syntax (Type)expr.
    *
    * For example: (int)f.
    */
   CXCursor_CStyleCastExpr                = 117,
 
   /** [C99 6.5.2.5]
    */
   CXCursor_CompoundLiteralExpr           = 118,
 
   /** Describes an C or C++ initializer list.
    */
   CXCursor_InitListExpr                  = 119,
 
   /** The GNU address of label extension, representing &&label.
    */
   CXCursor_AddrLabelExpr                 = 120,
 
   /** This is the GNU Statement Expression extension: ({int X=4; X;})
    */
   CXCursor_StmtExpr                      = 121,
 
   /** Represents a C11 generic selection.
    */
   CXCursor_GenericSelectionExpr          = 122,
 
   /** Implements the GNU __null extension, which is a name for a null
    * pointer constant that has integral type (e.g., int or long) and is the same
    * size and alignment as a pointer.
    *
    * The __null extension is typically only used by system headers, which define
    * NULL as __null in C++ rather than using 0 (which is an integer that may not
    * match the size of a pointer).
    */
   CXCursor_GNUNullExpr                   = 123,
 
   /** C++'s static_cast<> expression.
    */
   CXCursor_CXXStaticCastExpr             = 124,
 
   /** C++'s dynamic_cast<> expression.
    */
   CXCursor_CXXDynamicCastExpr            = 125,
 
   /** C++'s reinterpret_cast<> expression.
    */
   CXCursor_CXXReinterpretCastExpr        = 126,
 
   /** C++'s const_cast<> expression.
    */
   CXCursor_CXXConstCastExpr              = 127,
 
   /** Represents an explicit C++ type conversion that uses "functional"
    * notion (C++ [expr.type.conv]).
    *
    * Example:
    * \code
    *   x = int(0.5);
    * \endcode
    */
   CXCursor_CXXFunctionalCastExpr         = 128,
 
   /** A C++ typeid expression (C++ [expr.typeid]).
    */
   CXCursor_CXXTypeidExpr                 = 129,
 
   /** [C++ 2.13.5] C++ Boolean Literal.
    */
   CXCursor_CXXBoolLiteralExpr            = 130,
 
   /** [C++0x 2.14.7] C++ Pointer Literal.
    */
   CXCursor_CXXNullPtrLiteralExpr         = 131,
 
   /** Represents the "this" expression in C++
    */
   CXCursor_CXXThisExpr                   = 132,
 
   /** [C++ 15] C++ Throw Expression.
    *
    * This handles 'throw' and 'throw' assignment-expression. When
    * assignment-expression isn't present, Op will be null.
    */
   CXCursor_CXXThrowExpr                  = 133,
 
   /** A new expression for memory allocation and constructor calls, e.g:
    * "new CXXNewExpr(foo)".
    */
   CXCursor_CXXNewExpr                    = 134,
 
   /** A delete expression for memory deallocation and destructor calls,
    * e.g. "delete[] pArray".
    */
   CXCursor_CXXDeleteExpr                 = 135,
 
   /** A unary expression. (noexcept, sizeof, or other traits)
    */
   CXCursor_UnaryExpr                     = 136,
 
   /** An Objective-C string literal i.e. @"foo".
    */
   CXCursor_ObjCStringLiteral             = 137,
 
   /** An Objective-C \@encode expression.
    */
   CXCursor_ObjCEncodeExpr                = 138,
 
   /** An Objective-C \@selector expression.
    */
   CXCursor_ObjCSelectorExpr              = 139,
 
   /** An Objective-C \@protocol expression.
    */
   CXCursor_ObjCProtocolExpr              = 140,
 
   /** An Objective-C "bridged" cast expression, which casts between
    * Objective-C pointers and C pointers, transferring ownership in the process.
    *
    * \code
    *   NSString *str = (__bridge_transfer NSString *)CFCreateString();
    * \endcode
    */
   CXCursor_ObjCBridgedCastExpr           = 141,
 
   /** Represents a C++0x pack expansion that produces a sequence of
    * expressions.
    *
    * A pack expansion expression contains a pattern (which itself is an
    * expression) followed by an ellipsis. For example:
    *
    * \code
    * template<typename F, typename ...Types>
    * void forward(F f, Types &&...args) {
    *  f(static_cast<Types&&>(args)...);
    * }
    * \endcode
    */
   CXCursor_PackExpansionExpr             = 142,
 
   /** Represents an expression that computes the length of a parameter
    * pack.
    *
    * \code
    * template<typename ...Types>
    * struct count {
    *   static const unsigned value = sizeof...(Types);
    * };
    * \endcode
    */
   CXCursor_SizeOfPackExpr                = 143,
 
   /* Represents a C++ lambda expression that produces a local function
    * object.
    *
    * \code
    * void abssort(float *x, unsigned N) {
    *   std::sort(x, x + N,
    *             [](float a, float b) {
    *               return std::abs(a) < std::abs(b);
    *             });
    * }
    * \endcode
    */
   CXCursor_LambdaExpr                    = 144,
 
   /** Objective-c Boolean Literal.
    */
   CXCursor_ObjCBoolLiteralExpr           = 145,
 
   /** Represents the "self" expression in an Objective-C method.
    */
   CXCursor_ObjCSelfExpr                  = 146,
 
   /** OpenMP 4.0 [2.4, Array Section].
    */
   CXCursor_OMPArraySectionExpr           = 147,
 
   /** Represents an @available(...) check.
    */
   CXCursor_ObjCAvailabilityCheckExpr     = 148,
 
   /**
    * Fixed point literal
    */
   CXCursor_FixedPointLiteral             = 149,
 
-  CXCursor_LastExpr                      = CXCursor_FixedPointLiteral,
+  /** OpenMP 5.0 [2.1.4, Array Shaping].
+   */
+  CXCursor_OMPArrayShapingExpr           = 150,
+
+  CXCursor_LastExpr                      = CXCursor_OMPArrayShapingExpr,
 
   /* Statements */
   CXCursor_FirstStmt                     = 200,
   /**
    * A statement whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed statements have the same operations as any other kind of
    * statement; one can extract their location information, spelling,
    * children, etc. However, the specific kind of the statement is not
    * reported.
    */
   CXCursor_UnexposedStmt                 = 200,
 
   /** A labelled statement in a function.
    *
    * This cursor kind is used to describe the "start_over:" label statement in
    * the following example:
    *
    * \code
    *   start_over:
    *     ++counter;
    * \endcode
    *
    */
   CXCursor_LabelStmt                     = 201,
 
   /** A group of statements like { stmt stmt }.
    *
    * This cursor kind is used to describe compound statements, e.g. function
    * bodies.
    */
   CXCursor_CompoundStmt                  = 202,
 
   /** A case statement.
    */
   CXCursor_CaseStmt                      = 203,
 
   /** A default statement.
    */
   CXCursor_DefaultStmt                   = 204,
 
   /** An if statement
    */
   CXCursor_IfStmt                        = 205,
 
   /** A switch statement.
    */
   CXCursor_SwitchStmt                    = 206,
 
   /** A while statement.
    */
   CXCursor_WhileStmt                     = 207,
 
   /** A do statement.
    */
   CXCursor_DoStmt                        = 208,
 
   /** A for statement.
    */
   CXCursor_ForStmt                       = 209,
 
   /** A goto statement.
    */
   CXCursor_GotoStmt                      = 210,
 
   /** An indirect goto statement.
    */
   CXCursor_IndirectGotoStmt              = 211,
 
   /** A continue statement.
    */
   CXCursor_ContinueStmt                  = 212,
 
   /** A break statement.
    */
   CXCursor_BreakStmt                     = 213,
 
   /** A return statement.
    */
   CXCursor_ReturnStmt                    = 214,
 
   /** A GCC inline assembly statement extension.
    */
   CXCursor_GCCAsmStmt                    = 215,
   CXCursor_AsmStmt                       = CXCursor_GCCAsmStmt,
 
   /** Objective-C's overall \@try-\@catch-\@finally statement.
    */
   CXCursor_ObjCAtTryStmt                 = 216,
 
   /** Objective-C's \@catch statement.
    */
   CXCursor_ObjCAtCatchStmt               = 217,
 
   /** Objective-C's \@finally statement.
    */
   CXCursor_ObjCAtFinallyStmt             = 218,
 
   /** Objective-C's \@throw statement.
    */
   CXCursor_ObjCAtThrowStmt               = 219,
 
   /** Objective-C's \@synchronized statement.
    */
   CXCursor_ObjCAtSynchronizedStmt        = 220,
 
   /** Objective-C's autorelease pool statement.
    */
   CXCursor_ObjCAutoreleasePoolStmt       = 221,
 
   /** Objective-C's collection statement.
    */
   CXCursor_ObjCForCollectionStmt         = 222,
 
   /** C++'s catch statement.
    */
   CXCursor_CXXCatchStmt                  = 223,
 
   /** C++'s try statement.
    */
   CXCursor_CXXTryStmt                    = 224,
 
   /** C++'s for (* : *) statement.
    */
   CXCursor_CXXForRangeStmt               = 225,
 
   /** Windows Structured Exception Handling's try statement.
    */
   CXCursor_SEHTryStmt                    = 226,
 
   /** Windows Structured Exception Handling's except statement.
    */
   CXCursor_SEHExceptStmt                 = 227,
 
   /** Windows Structured Exception Handling's finally statement.
    */
   CXCursor_SEHFinallyStmt                = 228,
 
   /** A MS inline assembly statement extension.
    */
   CXCursor_MSAsmStmt                     = 229,
 
   /** The null statement ";": C99 6.8.3p3.
    *
    * This cursor kind is used to describe the null statement.
    */
   CXCursor_NullStmt                      = 230,
 
   /** Adaptor class for mixing declarations with statements and
    * expressions.
    */
   CXCursor_DeclStmt                      = 231,
 
   /** OpenMP parallel directive.
    */
   CXCursor_OMPParallelDirective          = 232,
 
   /** OpenMP SIMD directive.
    */
   CXCursor_OMPSimdDirective              = 233,
 
   /** OpenMP for directive.
    */
   CXCursor_OMPForDirective               = 234,
 
   /** OpenMP sections directive.
    */
   CXCursor_OMPSectionsDirective          = 235,
 
   /** OpenMP section directive.
    */
   CXCursor_OMPSectionDirective           = 236,
 
   /** OpenMP single directive.
    */
   CXCursor_OMPSingleDirective            = 237,
 
   /** OpenMP parallel for directive.
    */
   CXCursor_OMPParallelForDirective       = 238,
 
   /** OpenMP parallel sections directive.
    */
   CXCursor_OMPParallelSectionsDirective  = 239,
 
   /** OpenMP task directive.
    */
   CXCursor_OMPTaskDirective              = 240,
 
   /** OpenMP master directive.
    */
   CXCursor_OMPMasterDirective            = 241,
 
   /** OpenMP critical directive.
    */
   CXCursor_OMPCriticalDirective          = 242,
 
   /** OpenMP taskyield directive.
    */
   CXCursor_OMPTaskyieldDirective         = 243,
 
   /** OpenMP barrier directive.
    */
   CXCursor_OMPBarrierDirective           = 244,
 
   /** OpenMP taskwait directive.
    */
   CXCursor_OMPTaskwaitDirective          = 245,
 
   /** OpenMP flush directive.
    */
   CXCursor_OMPFlushDirective             = 246,
 
   /** Windows Structured Exception Handling's leave statement.
    */
   CXCursor_SEHLeaveStmt                  = 247,
 
   /** OpenMP ordered directive.
    */
   CXCursor_OMPOrderedDirective           = 248,
 
   /** OpenMP atomic directive.
    */
   CXCursor_OMPAtomicDirective            = 249,
 
   /** OpenMP for SIMD directive.
    */
   CXCursor_OMPForSimdDirective           = 250,
 
   /** OpenMP parallel for SIMD directive.
    */
   CXCursor_OMPParallelForSimdDirective   = 251,
 
   /** OpenMP target directive.
    */
   CXCursor_OMPTargetDirective            = 252,
 
   /** OpenMP teams directive.
    */
   CXCursor_OMPTeamsDirective             = 253,
 
   /** OpenMP taskgroup directive.
    */
   CXCursor_OMPTaskgroupDirective         = 254,
 
   /** OpenMP cancellation point directive.
    */
   CXCursor_OMPCancellationPointDirective = 255,
 
   /** OpenMP cancel directive.
    */
   CXCursor_OMPCancelDirective            = 256,
 
   /** OpenMP target data directive.
    */
   CXCursor_OMPTargetDataDirective        = 257,
 
   /** OpenMP taskloop directive.
    */
   CXCursor_OMPTaskLoopDirective          = 258,
 
   /** OpenMP taskloop simd directive.
    */
   CXCursor_OMPTaskLoopSimdDirective      = 259,
 
   /** OpenMP distribute directive.
    */
   CXCursor_OMPDistributeDirective        = 260,
 
   /** OpenMP target enter data directive.
    */
   CXCursor_OMPTargetEnterDataDirective   = 261,
 
   /** OpenMP target exit data directive.
    */
   CXCursor_OMPTargetExitDataDirective    = 262,
 
   /** OpenMP target parallel directive.
    */
   CXCursor_OMPTargetParallelDirective    = 263,
 
   /** OpenMP target parallel for directive.
    */
   CXCursor_OMPTargetParallelForDirective = 264,
 
   /** OpenMP target update directive.
    */
   CXCursor_OMPTargetUpdateDirective      = 265,
 
   /** OpenMP distribute parallel for directive.
    */
   CXCursor_OMPDistributeParallelForDirective = 266,
 
   /** OpenMP distribute parallel for simd directive.
    */
   CXCursor_OMPDistributeParallelForSimdDirective = 267,
enum CXCursorKind {
   CXCursor_OMPMasterTaskLoopDirective = 281,
 
   /** OpenMP parallel master taskloop directive.
    */
   CXCursor_OMPParallelMasterTaskLoopDirective = 282,
 
   /** OpenMP master taskloop simd directive.
    */
   CXCursor_OMPMasterTaskLoopSimdDirective      = 283,
 
   /** OpenMP parallel master taskloop simd directive.
    */
   CXCursor_OMPParallelMasterTaskLoopSimdDirective      = 284,
 
   /** OpenMP parallel master directive.
    */
   CXCursor_OMPParallelMasterDirective      = 285,
 
   /** OpenMP depobj directive.
    */
   CXCursor_OMPDepobjDirective             = 286,
 
   CXCursor_LastStmt = CXCursor_OMPDepobjDirective,
 
   /**
    * Cursor that represents the translation unit itself.
    *
    * The translation unit cursor exists primarily to act as the root
    * cursor for traversing the contents of a translation unit.
    */
   CXCursor_TranslationUnit               = 300,
 
   /* Attributes */
   CXCursor_FirstAttr                     = 400,
   /**
    * An attribute whose specific kind is not exposed via this
    * interface.
    */
   CXCursor_UnexposedAttr                 = 400,
 
   CXCursor_IBActionAttr                  = 401,
   CXCursor_IBOutletAttr                  = 402,
   CXCursor_IBOutletCollectionAttr        = 403,
   CXCursor_CXXFinalAttr                  = 404,
   CXCursor_CXXOverrideAttr               = 405,
   CXCursor_AnnotateAttr                  = 406,
   CXCursor_AsmLabelAttr                  = 407,
enum CXCursorKind {
   CXCursor_FlagEnum                      = 437,
   CXCursor_ConvergentAttr                = 438,
   CXCursor_WarnUnusedAttr                = 439,
   CXCursor_WarnUnusedResultAttr          = 440,
   CXCursor_AlignedAttr                   = 441,
   CXCursor_LastAttr                      = CXCursor_AlignedAttr,
 
   /* Preprocessing */
   CXCursor_PreprocessingDirective        = 500,
   CXCursor_MacroDefinition               = 501,
   CXCursor_MacroExpansion                = 502,
   CXCursor_MacroInstantiation            = CXCursor_MacroExpansion,
   CXCursor_InclusionDirective            = 503,
   CXCursor_FirstPreprocessing            = CXCursor_PreprocessingDirective,
   CXCursor_LastPreprocessing             = CXCursor_InclusionDirective,
 
   /* Extra Declarations */
   /**
    * A module import declaration.
    */
   CXCursor_ModuleImportDecl              = 600,
   CXCursor_TypeAliasTemplateDecl         = 601,
   /**
    * A static_assert or _Static_assert node
    */
   CXCursor_StaticAssert                  = 602,
   /**
    * a friend declaration.
    */
   CXCursor_FriendDecl                    = 603,
   CXCursor_FirstExtraDecl                = CXCursor_ModuleImportDecl,
   CXCursor_LastExtraDecl                 = CXCursor_FriendDecl,
 
   /**
    * A code completion overload candidate.
    */
   CXCursor_OverloadCandidate             = 700
 };
 
 /**
  * A cursor representing some element in the abstract syntax tree for
  * a translation unit.
  *
  * The cursor abstraction unifies the different kinds of entities in a
  * program--declaration, statements, expressions, references to declarations,

clang/include/clang/AST/ASTContext.h

public:
   CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
   CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
   CanQualType ObjCBuiltinBoolTy;
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   CanQualType SingletonId;
 #include "clang/Basic/OpenCLImageTypes.def"
   CanQualType OCLSamplerTy, OCLEventTy, OCLClkEventTy;
   CanQualType OCLQueueTy, OCLReserveIDTy;
-  CanQualType OMPArraySectionTy;
+  CanQualType OMPArraySectionTy, OMPArrayShapingTy;
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
   CanQualType Id##Ty;
 #include "clang/Basic/OpenCLExtensionTypes.def"
 #define SVE_TYPE(Name, Id, SingletonId) \
   CanQualType SingletonId;
 #include "clang/Basic/AArch64SVEACLETypes.def"
 
   // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.

clang/include/clang/AST/BuiltinTypes.def

 // The type of a cast which, in ARC, would normally require a
 // __bridge, but which might be okay depending on the immediate
 // context.
 PLACEHOLDER_TYPE(ARCUnbridgedCast, ARCUnbridgedCastTy)
 
 // A placeholder type for OpenMP array sections.
 PLACEHOLDER_TYPE(OMPArraySection, OMPArraySectionTy)
 
+// A placeholder type for OpenMP array shaping operation.
+PLACEHOLDER_TYPE(OMPArrayShaping, OMPArrayShapingTy)
+
 #ifdef LAST_BUILTIN_TYPE
-LAST_BUILTIN_TYPE(OMPArraySection)
+LAST_BUILTIN_TYPE(OMPArrayShaping)
 #undef LAST_BUILTIN_TYPE
 #endif
 
 #undef SHARED_SINGLETON_TYPE
 #undef PLACEHOLDER_TYPE
 #undef FLOATING_TYPE
 #undef SIGNED_TYPE
 #undef UNSIGNED_TYPE
 #undef BUILTIN_TYPE

clang/include/clang/AST/ExprOpenMP.h

public:
   child_range children() {
     return child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
   }
 
   const_child_range children() const {
     return const_child_range(&SubExprs[BASE], &SubExprs[END_EXPR]);
   }
 };
+
+/// An explicit cast in C or a C-style cast in C++, which uses the syntax
+/// ([s1][s2]...[sn])expr. For example: @c ([3][3])f.
+class OMPArrayShapingExpr final
+    : public Expr,
+      private llvm::TrailingObjects<OMPArrayShapingExpr, Expr *, SourceRange> {
+  friend TrailingObjects;
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+  /// Base node.
+  SourceLocation LPLoc; /// The location of the left paren
+  SourceLocation RPLoc; /// The location of the right paren
+  unsigned NumDims = 0; /// Number of dimensions in the shaping expression.
+
+  OMPArrayShapingExpr(QualType ExprTy, Expr *Op, SourceLocation L,
+                      SourceLocation R, unsigned NumDims)
+      : Expr(OMPArrayShapingExprClass, ExprTy, VK_LValue, OK_Ordinary,
+             Op->isTypeDependent() || ExprTy->isDependentType(),
+             Op->isValueDependent() || ExprTy->isDependentType(),
+             Op->isInstantiationDependent() ||
+                 ExprTy->isInstantiationDependentType(),
+             Op->containsUnexpandedParameterPack() ||
+                 ExprTy->containsUnexpandedParameterPack()),
+        LPLoc(L), RPLoc(R), NumDims(NumDims) {}
+
+  /// Construct an empty expression.
+  explicit OMPArrayShapingExpr(EmptyShell Shell, unsigned NumDims)
+      : Expr(OMPArrayShapingExprClass, Shell), NumDims(NumDims) {}
+
+  /// Sets the dimensions for the array shaping.
+  void setDimensions(ArrayRef<Expr *> Dims);
+
+  /// Sets the base expression for array shaping operation.
+  void setBase(Expr *Op) { getTrailingObjects<Expr *>()[NumDims] = Op; }
+
+  /// Sets source ranges for the brackets in the array shaping operation.
+  void setBracketsRanges(ArrayRef<SourceRange> BR);
+
+  unsigned numTrailingObjects(OverloadToken<Expr *>) const {
+    // Add an extra one for the base expression.
+    return NumDims + 1;
+  }
+
+  unsigned numTrailingObjects(OverloadToken<SourceRange>) const {
+    return NumDims;
+  }
+
+public:
+  static OMPArrayShapingExpr *Create(const ASTContext &Context, QualType T,
+                                     Expr *Op, SourceLocation L,
+                                     SourceLocation R, ArrayRef<Expr *> Dims,
+                                     ArrayRef<SourceRange> BracketRanges);
+
+  static OMPArrayShapingExpr *CreateEmpty(const ASTContext &Context,
+                                          unsigned NumDims);
+
+  SourceLocation getLParenLoc() const { return LPLoc; }
+  void setLParenLoc(SourceLocation L) { LPLoc = L; }
+
+  SourceLocation getRParenLoc() const { return RPLoc; }
+  void setRParenLoc(SourceLocation L) { RPLoc = L; }
+
+  SourceLocation getBeginLoc() const LLVM_READONLY { return LPLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return getBase()->getEndLoc();
+  }
+
+  /// Fetches the dimensions for array shaping expression.
+  ArrayRef<Expr *> getDimensions() const {
+    return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumDims);
+  }
+
+  /// Fetches source ranges for the brackets os the array shaping expression.
+  ArrayRef<SourceRange> getBracketsRanges() const {
+    return llvm::makeArrayRef(getTrailingObjects<SourceRange>(), NumDims);
+  }
+
+  /// Fetches base expression of array shaping expression.
+  Expr *getBase() { return getTrailingObjects<Expr *>()[NumDims]; }
+  const Expr *getBase() const { return getTrailingObjects<Expr *>()[NumDims]; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == OMPArrayShapingExprClass;
+  }
+
+  // Iterators
+  child_range children() {
+    Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
+    return child_range(Begin, Begin + NumDims + 1);
+  }
+  const_child_range children() const {
+    Stmt *const *Begin =
+        reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
+    return const_child_range(Begin, Begin + NumDims + 1);
+  }
+};
 } // end namespace clang
 
 #endif

clang/include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(CallExpr, {})
 DEF_TRAVERSE_STMT(CXXMemberCallExpr, {})
 
 // These exprs (most of them), do not need any action except iterating
 // over the children.
 DEF_TRAVERSE_STMT(AddrLabelExpr, {})
 DEF_TRAVERSE_STMT(ArraySubscriptExpr, {})
 DEF_TRAVERSE_STMT(OMPArraySectionExpr, {})
+DEF_TRAVERSE_STMT(OMPArrayShapingExpr, {})
 
 DEF_TRAVERSE_STMT(BlockExpr, {
   TRY_TO(TraverseDecl(S->getBlockDecl()));
   return true; // no child statements to loop through.
 })
 
 DEF_TRAVERSE_STMT(ChooseExpr, {})
 DEF_TRAVERSE_STMT(CompoundLiteralExpr, {

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_omp_reduction_incomplete_type : Error<
   "a reduction list item with incomplete type %0">;
 def err_omp_unexpected_clause_value : Error<
   "expected %0 in OpenMP clause '%1'">;
 def err_omp_expected_var_name_member_expr : Error<
   "expected variable name%select{| or data member of current class}0">;
 def err_omp_expected_var_name_member_expr_or_array_item : Error<
   "expected variable name%select{|, data member of current class}0, array element or array section">;
 def err_omp_expected_addressable_lvalue_or_array_item : Error<
-  "expected addressable lvalue expression, array element or array section%select{| of non 'omp_depend_t' type}0">;
+  "expected addressable lvalue expression, array element%select{ or array section|, array section or array shaping expression}0%select{| of non 'omp_depend_t' type}1">;
 def err_omp_expected_named_var_member_or_array_expression: Error<
   "expected expression containing only member accesses and/or array sections based on named variables">;
 def err_omp_bit_fields_forbidden_in_clause : Error<
   "bit fields cannot be used to specify storage in a '%0' clause">;
 def err_array_section_does_not_specify_contiguous_storage : Error<
   "array section does not specify contiguous storage">;
 def err_omp_union_type_not_allowed : Error<
   "mapping of union members is not allowed">;
def err_omp_mapper_wrong_type : Error<
   "mapper type must be of struct, union or class type">;
 def err_omp_declare_mapper_wrong_var : Error<
   "only variable %0 is allowed in map clauses of this 'omp declare mapper' directive">;
 def err_omp_declare_mapper_redefinition : Error<
   "redefinition of user-defined mapper for type %0 with name %1">;
 def err_omp_invalid_mapper: Error<
   "cannot find a valid user-defined mapper for type %0 with name %1">;
 def err_omp_array_section_use : Error<"OpenMP array section is not allowed here">;
+def err_omp_array_shaping_use : Error<"OpenMP array shaping operation is not allowed here">;
 def err_omp_typecheck_section_value : Error<
   "subscripted value is not an array or pointer">;
 def err_omp_typecheck_section_not_integer : Error<
   "array section %select{lower bound|length}0 is not an integer">;
+def err_omp_typecheck_shaping_not_integer : Error<
+  "array shaping operation dimension is not an integer">;
+def err_omp_shaping_dimension_not_positive : Error<
+  "array shaping dimension is evaluated to a non-positive value %0">;
 def err_omp_section_function_type : Error<
   "section of pointer to function type %0">;
 def warn_omp_section_is_char : Warning<"array section %select{lower bound|length}0 is of type 'char'">,
   InGroup<CharSubscript>, DefaultIgnore;
 def err_omp_section_incomplete_type : Error<
   "section of pointer to incomplete type %0">;
 def err_omp_section_not_subset_of_array : Error<
   "array section must be a subset of the original array">;

 def err_omp_lastprivate_conditional_non_scalar : Error<
   "expected list item of scalar type in 'lastprivate' clause with 'conditional' modifier"
   >;
 def err_omp_flush_order_clause_and_list : Error<
   "'flush' directive with memory order clause '%0' cannot have the list">;
 def note_omp_flush_order_clause_here : Note<
   "memory order clause '%0' is specified here">;
 def err_omp_non_lvalue_in_map_or_motion_clauses: Error<
-  "expected addressable lvalue in '%0' clause"
-  >;
+  "expected addressable lvalue in '%0' clause">;
+def err_omp_non_pointer_type_array_shaping_base : Error<
+  "expected pointer type expression as a base of an array shaping operation">;
 } // end of OpenMP category
 
 let CategoryName = "Related Result Type Issue" in {
 // Objective-C related result type compatibility
 def warn_related_result_type_compatibility_class : Warning<
   "method is expected to return an instance of its class type "
   "%diff{$, but is declared to return $|"
   ", but is declared to return different type}0,1">;

clang/include/clang/Basic/StmtNodes.td

 def BinaryOperator : StmtNode<Expr>;
 def CompoundAssignOperator : StmtNode<BinaryOperator>;
 def AbstractConditionalOperator : StmtNode<Expr, 1>;
 def ConditionalOperator : StmtNode<AbstractConditionalOperator>;
 def BinaryConditionalOperator : StmtNode<AbstractConditionalOperator>;
 def ImplicitCastExpr : StmtNode<CastExpr>;
 def ExplicitCastExpr : StmtNode<CastExpr, 1>;
 def CStyleCastExpr : StmtNode<ExplicitCastExpr>;
+def OMPArrayShapingExpr : StmtNode<Expr>;
 def CompoundLiteralExpr : StmtNode<Expr>;
 def ExtVectorElementExpr : StmtNode<Expr>;
 def InitListExpr : StmtNode<Expr>;
 def DesignatedInitExpr : StmtNode<Expr>;
 def DesignatedInitUpdateExpr : StmtNode<Expr>;
 def ImplicitValueInitExpr : StmtNode<Expr>;
 def NoInitExpr : StmtNode<Expr>;
 def ArrayInitLoopExpr : StmtNode<Expr>;

clang/include/clang/Parse/Parser.h

private:
 
   /// Parses 'omp declare mapper' directive.
   DeclGroupPtrTy ParseOpenMPDeclareMapperDirective(AccessSpecifier AS);
   /// Parses variable declaration in 'omp declare mapper' directive.
   TypeResult parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
                                              DeclarationName &Name,
                                              AccessSpecifier AS = AS_none);
 
+  /// Tries to parse cast part of OpenMP array shaping operation:
+  /// '[' expression ']' { '[' expression ']' } ')'.
+  bool tryParseOpenMPArrayShapingCastPart();
+
   /// Parses simple list of variables.
   ///
   /// \param Kind Kind of the directive.
   /// \param Callback Callback function to be called for the list elements.
   /// \param AllowScopeSpecifier true, if the variables can have fully
   /// qualified names.
   ///
   bool ParseOpenMPSimpleVarList(

clang/include/clang/Sema/Sema.h

public:
 
   ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
                                      Expr *Idx, SourceLocation RLoc);
   ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
                                              Expr *Idx, SourceLocation RLoc);
   ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
                                       Expr *LowerBound, SourceLocation ColonLoc,
                                       Expr *Length, SourceLocation RBLoc);
+  ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
+                                      SourceLocation RParenLoc,
+                                      ArrayRef<Expr *> Dims,
+                                      ArrayRef<SourceRange> Brackets);
 
   // This struct is for use by ActOnMemberAccess to allow
   // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
   // changing the access operator from a '.' to a '->' (to see if that is the
   // change needed to fix an error about an unknown member, e.g. when the class
   // defines a custom operator->).
   struct ActOnMemberAccessExtraArgs {
     Scope *S;

clang/include/clang/Serialization/ASTBitCodes.h

namespace serialization {
     ///
     /// These type IDs correspond to predefined types in the AST
     /// context, such as built-in types (int) and special place-holder
     /// types (the \<overload> and \<dependent> type markers). Such
     /// types are never actually serialized, since they will be built
     /// by the AST context when it is created.
     enum PredefinedTypeIDs {
       /// The NULL type.
       PREDEF_TYPE_NULL_ID       = 0,
 
       /// The void type.
       PREDEF_TYPE_VOID_ID       = 1,
 
       /// The 'bool' or '_Bool' type.
       PREDEF_TYPE_BOOL_ID       = 2,
 
       /// The 'char' type, when it is unsigned.
       PREDEF_TYPE_CHAR_U_ID     = 3,
 
       /// The 'unsigned char' type.
       PREDEF_TYPE_UCHAR_ID      = 4,
 
       /// The 'unsigned short' type.
       PREDEF_TYPE_USHORT_ID     = 5,
 
       /// The 'unsigned int' type.
       PREDEF_TYPE_UINT_ID       = 6,
 
       /// The 'unsigned long' type.
       PREDEF_TYPE_ULONG_ID      = 7,
 
       /// The 'unsigned long long' type.
       PREDEF_TYPE_ULONGLONG_ID  = 8,
 
       /// The 'char' type, when it is signed.
       PREDEF_TYPE_CHAR_S_ID     = 9,
 
       /// The 'signed char' type.
       PREDEF_TYPE_SCHAR_ID      = 10,
 
       /// The C++ 'wchar_t' type.
       PREDEF_TYPE_WCHAR_ID      = 11,
 
       /// The (signed) 'short' type.
       PREDEF_TYPE_SHORT_ID      = 12,
 
       /// The (signed) 'int' type.
       PREDEF_TYPE_INT_ID        = 13,
 
       /// The (signed) 'long' type.
       PREDEF_TYPE_LONG_ID       = 14,
 
       /// The (signed) 'long long' type.
       PREDEF_TYPE_LONGLONG_ID   = 15,
 
       /// The 'float' type.
       PREDEF_TYPE_FLOAT_ID      = 16,
 
       /// The 'double' type.
       PREDEF_TYPE_DOUBLE_ID     = 17,
 
       /// The 'long double' type.
       PREDEF_TYPE_LONGDOUBLE_ID = 18,
 
       /// The placeholder type for overloaded function sets.
       PREDEF_TYPE_OVERLOAD_ID   = 19,
 
       /// The placeholder type for dependent types.
       PREDEF_TYPE_DEPENDENT_ID  = 20,
 
       /// The '__uint128_t' type.
       PREDEF_TYPE_UINT128_ID    = 21,
 
       /// The '__int128_t' type.
       PREDEF_TYPE_INT128_ID     = 22,
 
       /// The type of 'nullptr'.
       PREDEF_TYPE_NULLPTR_ID    = 23,
 
       /// The C++ 'char16_t' type.
       PREDEF_TYPE_CHAR16_ID     = 24,
 
       /// The C++ 'char32_t' type.
       PREDEF_TYPE_CHAR32_ID     = 25,
 
       /// The ObjC 'id' type.
       PREDEF_TYPE_OBJC_ID       = 26,
 
       /// The ObjC 'Class' type.
       PREDEF_TYPE_OBJC_CLASS    = 27,
 
       /// The ObjC 'SEL' type.
       PREDEF_TYPE_OBJC_SEL      = 28,
 
       /// The 'unknown any' placeholder type.
       PREDEF_TYPE_UNKNOWN_ANY   = 29,
 
       /// The placeholder type for bound member functions.
       PREDEF_TYPE_BOUND_MEMBER  = 30,
 
       /// The "auto" deduction type.
       PREDEF_TYPE_AUTO_DEDUCT   = 31,
 
       /// The "auto &&" deduction type.
       PREDEF_TYPE_AUTO_RREF_DEDUCT = 32,
 
       /// The OpenCL 'half' / ARM NEON __fp16 type.
       PREDEF_TYPE_HALF_ID       = 33,
 
       /// ARC's unbridged-cast placeholder type.
       PREDEF_TYPE_ARC_UNBRIDGED_CAST = 34,
 
       /// The pseudo-object placeholder type.
       PREDEF_TYPE_PSEUDO_OBJECT = 35,
 
       /// The placeholder type for builtin functions.
       PREDEF_TYPE_BUILTIN_FN = 36,
 
       /// OpenCL event type.
       PREDEF_TYPE_EVENT_ID      = 37,
 
       /// OpenCL clk event type.
       PREDEF_TYPE_CLK_EVENT_ID  = 38,
 
       /// OpenCL sampler type.
       PREDEF_TYPE_SAMPLER_ID    = 39,
 
       /// OpenCL queue type.
       PREDEF_TYPE_QUEUE_ID      = 40,
 
       /// OpenCL reserve_id type.
       PREDEF_TYPE_RESERVE_ID_ID = 41,
 
       /// The placeholder type for OpenMP array section.
       PREDEF_TYPE_OMP_ARRAY_SECTION = 42,
 
       /// The '__float128' type
       PREDEF_TYPE_FLOAT128_ID = 43,
 
       /// The '_Float16' type
       PREDEF_TYPE_FLOAT16_ID = 44,
 
       /// The C++ 'char8_t' type.
       PREDEF_TYPE_CHAR8_ID = 45,
 
       /// \brief The 'short _Accum' type
       PREDEF_TYPE_SHORT_ACCUM_ID    = 46,
 
       /// \brief The '_Accum' type
       PREDEF_TYPE_ACCUM_ID      = 47,
 
       /// \brief The 'long _Accum' type
       PREDEF_TYPE_LONG_ACCUM_ID = 48,
 
       /// \brief The 'unsigned short _Accum' type
       PREDEF_TYPE_USHORT_ACCUM_ID   = 49,
 
       /// \brief The 'unsigned _Accum' type
       PREDEF_TYPE_UACCUM_ID     = 50,
 
       /// \brief The 'unsigned long _Accum' type
       PREDEF_TYPE_ULONG_ACCUM_ID    = 51,
 
       /// \brief The 'short _Fract' type
       PREDEF_TYPE_SHORT_FRACT_ID = 52,
 
       /// \brief The '_Fract' type
       PREDEF_TYPE_FRACT_ID = 53,
 
       /// \brief The 'long _Fract' type
enum PredefinedTypeIDs {
       PREDEF_TYPE_SAT_USHORT_FRACT_ID = 67,
 
       /// \brief The '_Sat unsigned _Fract' type
       PREDEF_TYPE_SAT_UFRACT_ID = 68,
 
       /// \brief The '_Sat unsigned long _Fract' type
       PREDEF_TYPE_SAT_ULONG_FRACT_ID = 69,
 
+      /// The placeholder type for OpenMP array shaping operation.
+      PREDEF_TYPE_OMP_ARRAY_SHAPING = 70,
+
       /// OpenCL image types with auto numeration
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
       PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLImageTypes.def"
       /// \brief OpenCL extension types with auto numeration
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
       PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLExtensionTypes.def"
       // \brief SVE types with auto numeration
enum StmtCode {
       EXPR_USER_DEFINED_LITERAL,
 
       /// A CXXStdInitializerListExpr record.
       EXPR_CXX_STD_INITIALIZER_LIST,
 
       /// A CXXBoolLiteralExpr record.
       EXPR_CXX_BOOL_LITERAL,
 
       EXPR_CXX_NULL_PTR_LITERAL,  // CXXNullPtrLiteralExpr
       EXPR_CXX_TYPEID_EXPR,       // CXXTypeidExpr (of expr).
       EXPR_CXX_TYPEID_TYPE,       // CXXTypeidExpr (of type).
       EXPR_CXX_THIS,              // CXXThisExpr
       EXPR_CXX_THROW,             // CXXThrowExpr
       EXPR_CXX_DEFAULT_ARG,       // CXXDefaultArgExpr
       EXPR_CXX_DEFAULT_INIT,      // CXXDefaultInitExpr
       EXPR_CXX_BIND_TEMPORARY,    // CXXBindTemporaryExpr
 
       EXPR_CXX_SCALAR_VALUE_INIT, // CXXScalarValueInitExpr
       EXPR_CXX_NEW,               // CXXNewExpr
       EXPR_CXX_DELETE,            // CXXDeleteExpr
       EXPR_CXX_PSEUDO_DESTRUCTOR, // CXXPseudoDestructorExpr
 
       EXPR_EXPR_WITH_CLEANUPS,    // ExprWithCleanups
 
       EXPR_CXX_DEPENDENT_SCOPE_MEMBER,   // CXXDependentScopeMemberExpr
       EXPR_CXX_DEPENDENT_SCOPE_DECL_REF, // DependentScopeDeclRefExpr
       EXPR_CXX_UNRESOLVED_CONSTRUCT,     // CXXUnresolvedConstructExpr
       EXPR_CXX_UNRESOLVED_MEMBER,        // UnresolvedMemberExpr
       EXPR_CXX_UNRESOLVED_LOOKUP,        // UnresolvedLookupExpr
 
       EXPR_CXX_EXPRESSION_TRAIT,  // ExpressionTraitExpr
       EXPR_CXX_NOEXCEPT,          // CXXNoexceptExpr
 
       EXPR_OPAQUE_VALUE,          // OpaqueValueExpr
       EXPR_BINARY_CONDITIONAL_OPERATOR,  // BinaryConditionalOperator
       EXPR_TYPE_TRAIT,            // TypeTraitExpr
       EXPR_ARRAY_TYPE_TRAIT,      // ArrayTypeTraitIntExpr
 
       EXPR_PACK_EXPANSION,        // PackExpansionExpr
       EXPR_SIZEOF_PACK,           // SizeOfPackExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,// SubstNonTypeTemplateParmPackExpr
       EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
       EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
       EXPR_CXX_FOLD,              // CXXFoldExpr
       EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
       EXPR_REQUIRES,              // RequiresExpr
 
       // CUDA
       EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr
 
       // OpenCL
       EXPR_ASTYPE,                 // AsTypeExpr
 
       // Microsoft
       EXPR_CXX_PROPERTY_REF_EXPR, // MSPropertyRefExpr
       EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR, // MSPropertySubscriptExpr
       EXPR_CXX_UUIDOF_EXPR,       // CXXUuidofExpr (of expr).
       EXPR_CXX_UUIDOF_TYPE,       // CXXUuidofExpr (of type).
       STMT_SEH_LEAVE,             // SEHLeaveStmt
       STMT_SEH_EXCEPT,            // SEHExceptStmt
       STMT_SEH_FINALLY,           // SEHFinallyStmt
       STMT_SEH_TRY,               // SEHTryStmt
 
       // OpenMP directives
       STMT_OMP_PARALLEL_DIRECTIVE,
enum StmtCode {
       STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
       STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
       STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
       EXPR_OMP_ARRAY_SECTION,
+      EXPR_OMP_ARRAY_SHAPING,
 
       // ARC
       EXPR_OBJC_BRIDGED_CAST,     // ObjCBridgedCastExpr
 
       STMT_MS_DEPENDENT_EXISTS,   // MSDependentExistsStmt
       EXPR_LAMBDA,                // LambdaExpr
       STMT_COROUTINE_BODY,
       STMT_CORETURN,
       EXPR_COAWAIT,
       EXPR_COYIELD,
       EXPR_DEPENDENT_COAWAIT,
     };
 

clang/lib/AST/ASTContext.cpp

void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
 
   // Placeholder type for unbridged ARC casts.
   InitBuiltinType(ARCUnbridgedCastTy,  BuiltinType::ARCUnbridgedCast);
 
   // Placeholder type for builtin functions.
   InitBuiltinType(BuiltinFnTy,  BuiltinType::BuiltinFn);
 
   // Placeholder type for OMP array sections.
-  if (LangOpts.OpenMP)
+  if (LangOpts.OpenMP) {
     InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);
+    InitBuiltinType(OMPArrayShapingTy, BuiltinType::OMPArrayShaping);
+  }
 
   // C99 6.2.5p11.
   FloatComplexTy      = getComplexType(FloatTy);
   DoubleComplexTy     = getComplexType(DoubleTy);
   LongDoubleComplexTy = getComplexType(LongDoubleTy);
   Float128ComplexTy   = getComplexType(Float128Ty);
 
   // Builtin types for 'id', 'Class', and 'SEL'.

clang/lib/AST/Expr.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DependencyFlags.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/Mangle.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Lexer.h"
case ExprWithCleanupsClass:
     if (IncludePossibleEffects)
       if (cast<ExprWithCleanups>(this)->cleanupsHaveSideEffects())
         return true;
     break;
 
   case ParenExprClass:
   case ArraySubscriptExprClass:
   case OMPArraySectionExprClass:
+  case OMPArrayShapingExprClass:
   case MemberExprClass:
   case ConditionalOperatorClass:
   case BinaryConditionalOperatorClass:
   case CompoundLiteralExprClass:
   case ExtVectorElementExprClass:
   case DesignatedInitExprClass:
   case DesignatedInitUpdateExprClass:
   case ArrayInitLoopExprClass:
if (OriginalTy->isAnyPointerType())
       OriginalTy = OriginalTy->getPointeeType();
     else {
       assert (OriginalTy->isArrayType());
       OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
     }
   }
   return OriginalTy;
 }
+
+void OMPArrayShapingExpr::setDimensions(ArrayRef<Expr *> Dims) {
+  assert(
+      NumDims == Dims.size() &&
+      "Preallocated number of dimensions is different from the provided one.");
+  llvm::copy(Dims, getTrailingObjects<Expr *>());
+}
+
+void OMPArrayShapingExpr::setBracketsRanges(ArrayRef<SourceRange> BR) {
+  assert(
+      NumDims == BR.size() &&
+      "Preallocated number of dimensions is different from the provided one.");
+  llvm::copy(BR, getTrailingObjects<SourceRange>());
+}
+
+OMPArrayShapingExpr *
+OMPArrayShapingExpr::Create(const ASTContext &Context, QualType T, Expr *Op,
+                            SourceLocation L, SourceLocation R,
+                            ArrayRef<Expr *> Dims,
+                            ArrayRef<SourceRange> BracketRanges) {
+  assert(Dims.size() == BracketRanges.size() &&
+         "Different number of dimensions and brackets ranges.");
+  void *Mem = Context.Allocate(
+      totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),
+      alignof(OMPArrayShapingExpr));
+  auto *E = new (Mem) OMPArrayShapingExpr(T, Op, L, R, Dims.size());
+  E->setBase(Op);
+  E->setDimensions(Dims);
+  E->setBracketsRanges(BracketRanges);
+  return E;
+}
+
+OMPArrayShapingExpr *OMPArrayShapingExpr::CreateEmpty(const ASTContext &Context,
+                                                      unsigned NumDims) {
+  void *Mem = Context.Allocate(
+      totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),
+      alignof(OMPArrayShapingExpr));
+  return new (Mem) OMPArrayShapingExpr(EmptyShell(), NumDims);
+}

clang/lib/AST/ExprClassification.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::DependentScopeDeclRefExprClass:
     // ObjC instance variables are lvalues
     // FIXME: ObjC++0x might have different rules
   case Expr::ObjCIvarRefExprClass:
   case Expr::FunctionParmPackExprClass:
   case Expr::MSPropertyRefExprClass:
   case Expr::MSPropertySubscriptExprClass:
   case Expr::OMPArraySectionExprClass:
+  case Expr::OMPArrayShapingExprClass:
     return Cl::CL_LValue;
 
     // C99 6.5.2.5p5 says that compound literals are lvalues.
     // In C++, they're prvalue temporaries, except for file-scope arrays.
   case Expr::CompoundLiteralExprClass:
     return !E->isLValue() ? ClassifyTemporary(E->getType()) : Cl::CL_LValue;
 
     // Expressions that are prvalues.

clang/lib/AST/ExprConstant.cpp

 #define EXPR(Node, Base)
 #include "clang/AST/StmtNodes.inc"
   case Expr::PredefinedExprClass:
   case Expr::FloatingLiteralClass:
   case Expr::ImaginaryLiteralClass:
   case Expr::StringLiteralClass:
   case Expr::ArraySubscriptExprClass:
   case Expr::OMPArraySectionExprClass:
+  case Expr::OMPArrayShapingExprClass:
   case Expr::MemberExprClass:
   case Expr::CompoundAssignOperatorClass:
   case Expr::CompoundLiteralExprClass:
   case Expr::ExtVectorElementExprClass:
   case Expr::DesignatedInitExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:

clang/lib/AST/ItaniumMangle.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::ParenListExprClass:
   case Expr::LambdaExprClass:
   case Expr::MSPropertyRefExprClass:
   case Expr::MSPropertySubscriptExprClass:
   case Expr::TypoExprClass:  // This should no longer exist in the AST by now.
   case Expr::OMPArraySectionExprClass:
+  case Expr::OMPArrayShapingExprClass:
   case Expr::CXXInheritedCtorInitExprClass:
     llvm_unreachable("unexpected statement kind");
 
   case Expr::ConstantExprClass:
     E = cast<ConstantExpr>(E)->getSubExpr();
     goto recurse;
 
   // FIXME: invent manglings for all these.

clang/lib/AST/NSAPI.cpp

#include "clang/Basic/AArch64SVEACLETypes.def"
   case BuiltinType::Dependent:
   case BuiltinType::Overload:
   case BuiltinType::UnknownAny:
   case BuiltinType::ARCUnbridgedCast:
   case BuiltinType::Half:
   case BuiltinType::PseudoObject:
   case BuiltinType::BuiltinFn:
   case BuiltinType::OMPArraySection:
+  case BuiltinType::OMPArrayShaping:
     break;
   }
 
   return None;
 }
 
 /// Returns true if \param T is a typedef of "BOOL" in objective-c.
 bool NSAPI::isObjCBOOLType(QualType T) const {

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitOMPArraySectionExpr(OMPArraySectionExpr *Node) {
   if (Node->getColonLoc().isValid()) {
     OS << ":";
     if (Node->getLength())
       PrintExpr(Node->getLength());
   }
   OS << "]";
 }
 
+void StmtPrinter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *Node) {
+  OS << "(";
+  for (Expr *E : Node->getDimensions()) {
+    OS << "[";
+    PrintExpr(E);
+    OS << "]";
+  }
+  OS << ")";
+  PrintExpr(Node->getBase());
+}
+
 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
   for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
     if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
       // Don't print any defaulted arguments
       break;
     }
 
     if (i) OS << ", ";

clang/lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitOMPArraySectionExpr(const OMPArraySectionExpr *S) {
   VisitExpr(S);
 }
 
+void StmtProfiler::VisitOMPArrayShapingExpr(const OMPArrayShapingExpr *S) {
+  VisitExpr(S);
+}
+
 void StmtProfiler::VisitCallExpr(const CallExpr *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitMemberExpr(const MemberExpr *S) {
   VisitExpr(S);
   VisitDecl(S->getMemberDecl());
   if (!Canonical)

clang/lib/AST/Type.cpp

#include "clang/Basic/OpenCLImageTypes.def"
   case OCLClkEvent:
     return "clk_event_t";
   case OCLQueue:
     return "queue_t";
   case OCLReserveID:
     return "reserve_id_t";
   case OMPArraySection:
     return "<OpenMP array section type>";
+  case OMPArrayShaping:
+    return "<OpenMP array shaping type>";
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
   case Id: \
     return #ExtType;
 #include "clang/Basic/OpenCLExtensionTypes.def"
 #define SVE_TYPE(Name, Id, SingletonId) \
   case Id: \
     return Name;
 #include "clang/Basic/AArch64SVEACLETypes.def"
#include "clang/Basic/OpenCLExtensionTypes.def"
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
 #define SVE_TYPE(Name, Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
     case BuiltinType::BuiltinFn:
     case BuiltinType::NullPtr:
     case BuiltinType::OMPArraySection:
+    case BuiltinType::OMPArrayShaping:
       return false;
     }
     llvm_unreachable("unknown builtin type");
 
   // Non-pointer types.
   case Type::Complex:
   case Type::LValueReference:
   case Type::RValueReference:

clang/lib/AST/TypeLoc.cpp

#include "clang/Basic/OpenCLExtensionTypes.def"
   case BuiltinType::OCLClkEvent:
   case BuiltinType::OCLQueue:
   case BuiltinType::OCLReserveID:
 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
   case BuiltinType::BuiltinFn:
   case BuiltinType::OMPArraySection:
+  case BuiltinType::OMPArrayShaping:
     return TST_unspecified;
   }
 
   llvm_unreachable("Invalid BuiltinType Kind!");
 }
 
 TypeLoc TypeLoc::IgnoreParensImpl(TypeLoc TL) {
   while (ParenTypeLoc PTL = TL.getAs<ParenTypeLoc>())

clang/lib/Parse/ParseExpr.cpp

ExprResult Parser::ParseBuiltinPrimaryExpression() {
   if (Res.isInvalid())
     return ExprError();
 
   // These can be followed by postfix-expr pieces because they are
   // primary-expressions.
   return ParsePostfixExpressionSuffix(Res.get());
 }
 
+bool Parser::tryParseOpenMPArrayShapingCastPart() {
+  assert(Tok.is(tok::l_square) && "Expected open bracket");
+  bool ErrorFound = true;
+  TentativeParsingAction TPA(*this);
+  do {
+    if (Tok.isNot(tok::l_square))
+      break;
+    // Consume '['
+    ConsumeBracket();
+    // Skip inner expression.
+    while (!SkipUntil(tok::r_square, tok::annot_pragma_openmp_end,
+                      StopAtSemi | StopBeforeMatch))
+      ;
+    if (Tok.isNot(tok::r_square))
+      break;
+    // Consume ']'
+    ConsumeBracket();
+    // Found ')' - done.
+    if (Tok.is(tok::r_paren)) {
+      ErrorFound = false;
+      break;
+    }
+  } while (Tok.isNot(tok::annot_pragma_openmp_end));
+  TPA.Revert();
+  return !ErrorFound;
+}
+
 /// ParseParenExpression - This parses the unit that starts with a '(' token,
 /// based on what is allowed by ExprType.  The actual thing parsed is returned
 /// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
 /// not the parsed cast-expression.
 ///
 /// \verbatim
 ///       primary-expression: [C99 6.5.1]
 ///         '(' expression ')'
 /// [GNU]   '(' compound-statement ')'      (if !ParenExprOnly)
 ///       postfix-expression: [C99 6.5.2]
 ///         '(' type-name ')' '{' initializer-list '}'
 ///         '(' type-name ')' '{' initializer-list ',' '}'
 ///       cast-expression: [C99 6.5.4]
 ///         '(' type-name ')' cast-expression
 /// [ARC]   bridged-cast-expression
 /// [ARC] bridged-cast-expression:
 ///         (__bridge type-name) cast-expression
 ///         (__bridge_transfer type-name) cast-expression
 ///         (__bridge_retained type-name) cast-expression
 ///       fold-expression: [C++1z]
 ///         '(' cast-expression fold-operator '...' ')'
 ///         '(' '...' fold-operator cast-expression ')'
 ///         '(' cast-expression fold-operator '...'
 ///                 fold-operator cast-expression ')'
+/// [OPENMP] Array shaping operation
+///       '(' '[' expression ']' { '[' expression ']' } cast-expression
 /// \endverbatim
 ExprResult
 Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
                              bool isTypeCast, ParsedType &CastTy,
                              SourceLocation &RParenLoc) {
   assert(Tok.is(tok::l_paren) && "Not a paren expr!");
   ColonProtectionRAIIObject ColonProtection(*this, false);
   BalancedDelimiterTracker T(*this, tok::l_paren);
if (!ParseSimpleExpressionList(ArgExprs, CommaLocs)) {
           isFoldOperator(Tok.getKind()) && NextToken().is(tok::ellipsis)) {
         ExprType = FoldExpr;
         return ParseFoldExpression(ArgExprs[0], T);
       }
 
       ExprType = SimpleExpr;
       Result = Actions.ActOnParenListExpr(OpenLoc, Tok.getLocation(),
                                           ArgExprs);
     }
+  } else if (getLangOpts().OpenMP >= 50 && OpenMPDirectiveParsing &&
+             ExprType == CastExpr && Tok.is(tok::l_square) &&
+             tryParseOpenMPArrayShapingCastPart()) {
+    bool ErrorFound = false;
+    SmallVector<Expr *, 4> OMPDimensions;
+    SmallVector<SourceRange, 4> OMPBracketsRanges;
+    do {
+      BalancedDelimiterTracker TS(*this, tok::l_square);
+      TS.consumeOpen();
+      ExprResult NumElements =
+          Actions.CorrectDelayedTyposInExpr(ParseExpression());
+      if (!NumElements.isUsable()) {
+        ErrorFound = true;
+        while (!SkipUntil(tok::r_square, tok::r_paren,
+                          StopAtSemi | StopBeforeMatch))
+          ;
+      }
+      TS.consumeClose();
+      OMPDimensions.push_back(NumElements.get());
+      OMPBracketsRanges.push_back(TS.getRange());
+    } while (Tok.isNot(tok::r_paren));
+    // Match the ')'.
+    T.consumeClose();
+    RParenLoc = T.getCloseLocation();
+    Result = Actions.CorrectDelayedTyposInExpr(ParseExpression());
+    if (ErrorFound) {
+      Result = ExprError();
+    } else if (!Result.isInvalid()) {
+      Result = Actions.ActOnOMPArrayShapingExpr(
+          Result.get(), OpenLoc, RParenLoc, OMPDimensions, OMPBracketsRanges);
+    }
+    return Result;
   } else {
     InMessageExpressionRAIIObject InMessage(*this, false);
 
     Result = ParseExpression(MaybeTypeCast);
     if (!getLangOpts().CPlusPlus && MaybeTypeCast && Result.isUsable()) {
       // Correct typos in non-C++ code earlier so that implicit-cast-like
       // expressions are parsed correctly.
       Result = Actions.CorrectDelayedTyposInExpr(Result);

clang/lib/Sema/SemaExceptionSpec.cpp

case Expr::BuiltinBitCastExprClass:
       // FIXME: Properly determine whether a variably-modified type can throw.
     if (cast<Expr>(S)->getType()->isVariablyModifiedType())
       return CT_Can;
     return canSubStmtsThrow(*this, S);
 
     // Some might be dependent for other reasons.
   case Expr::ArraySubscriptExprClass:
   case Expr::OMPArraySectionExprClass:
+  case Expr::OMPArrayShapingExprClass:
   case Expr::BinaryOperatorClass:
   case Expr::DependentCoawaitExprClass:
   case Expr::CompoundAssignOperatorClass:
   case Expr::CStyleCastExprClass:
   case Expr::CXXStaticCastExprClass:
   case Expr::CXXFunctionalCastExprClass:
   case Expr::ImplicitCastExprClass:
   case Expr::MaterializeTemporaryExprClass:

clang/lib/Sema/SemaExpr.cpp

if (Result.isInvalid())
       return ExprError();
     Base = Result.get();
   }
   return new (Context)
       OMPArraySectionExpr(Base, LowerBound, Length, Context.OMPArraySectionTy,
                           VK_LValue, OK_Ordinary, ColonLoc, RBLoc);
 }
 
+ExprResult Sema::ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
+                                          SourceLocation RParenLoc,
+                                          ArrayRef<Expr *> Dims,
+                                          ArrayRef<SourceRange> Brackets) {
+  if (Base->getType()->isPlaceholderType()) {
+    ExprResult Result = CheckPlaceholderExpr(Base);
+    if (Result.isInvalid())
+      return ExprError();
+    Base = Result.get();
+  }
+  QualType BaseTy = Base->getType();
+  // Delay analysis of the types/expressions if instantiation/specialization is
+  // required.
+  if (!BaseTy->isAnyPointerType() &&
+      (Base->isValueDependent() || Base->isTypeDependent() ||
+       Base->isInstantiationDependent() ||
+       Base->containsUnexpandedParameterPack()))
+    return OMPArrayShapingExpr::Create(Context, Context.DependentTy, Base,
+                                       LParenLoc, RParenLoc, Dims, Brackets);
+  if (!BaseTy->isAnyPointerType())
+    return ExprError(Diag(Base->getExprLoc(),
+                          diag::err_omp_non_pointer_type_array_shaping_base)
+                     << Base->getSourceRange());
+  SmallVector<Expr *, 4> NewDims;
+  bool ErrorFound = false;
+  for (Expr *Dim : Dims) {
+    if (Dim->getType()->isNonOverloadPlaceholderType()) {
+      ExprResult Result = CheckPlaceholderExpr(Dim);
+      if (Result.isInvalid()) {
+        ErrorFound = true;
+        continue;
+      }
+      Result = DefaultLvalueConversion(Result.get());
+      if (Result.isInvalid()) {
+        ErrorFound = true;
+        continue;
+      }
+      Dim = Result.get();
+    }
+    if (!Dim->isValueDependent() && !Dim->isTypeDependent()) {
+      ExprResult Result =
+          PerformOpenMPImplicitIntegerConversion(Dim->getExprLoc(), Dim);
+      if (Result.isInvalid()) {
+        ErrorFound = true;
+        Diag(Dim->getExprLoc(), diag::err_omp_typecheck_shaping_not_integer)
+            << Dim->getSourceRange();
+        continue;
+      }
+      Dim = Result.get();
+      Expr::EvalResult EvResult;
+      if (Dim->EvaluateAsInt(EvResult, Context)) {
+        // OpenMP 5.0, [2.1.4 Array Shaping]
+        // Each si is an integral type expression that must evaluate to a
+        // positive integer.
+        llvm::APSInt Value = EvResult.Val.getInt();
+        if (!Value.isStrictlyPositive()) {
+          Diag(Dim->getExprLoc(), diag::err_omp_shaping_dimension_not_positive)
+              << Value.toString(/*Radix=*/10, /*Signed=*/true)
+              << Dim->getSourceRange();
+          ErrorFound = true;
+          continue;
+        }
+      }
+    }
+    NewDims.push_back(Dim);
+  }
+  if (ErrorFound)
+    return ExprError();
+  return OMPArrayShapingExpr::Create(Context, Context.OMPArrayShapingTy, Base,
+                                     LParenLoc, RParenLoc, NewDims, Brackets);
+}
+
 ExprResult
 Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
                                       Expr *Idx, SourceLocation RLoc) {
   Expr *LHSExp = Base;
   Expr *RHSExp = Idx;
 
   ExprValueKind VK = VK_LValue;
   ExprObjectKind OK = OK_Ordinary;
#include "clang/AST/BuiltinTypes.def"
   // to resolve unknown-typed arguments based on known parameter types.
   case BuiltinType::UnknownAny:
     return true;
 
   // These are always invalid as call arguments and should be reported.
   case BuiltinType::BoundMember:
   case BuiltinType::BuiltinFn:
   case BuiltinType::OMPArraySection:
+  case BuiltinType::OMPArrayShaping:
     return true;
 
   }
   llvm_unreachable("bad builtin type kind");
 }
 
 /// Check an argument list for placeholders that we won't try to
 /// handle later.
case BuiltinType::BuiltinFn: {
     return ExprError();
   }
 
   // Expressions of unknown type.
   case BuiltinType::OMPArraySection:
     Diag(E->getBeginLoc(), diag::err_omp_array_section_use);
     return ExprError();
 
+  // Expressions of unknown type.
+  case BuiltinType::OMPArrayShaping:
+    return ExprError(Diag(E->getBeginLoc(), diag::err_omp_array_shaping_use));
+
   // Everything else should be impossible.
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
 #define SVE_TYPE(Name, Id, SingletonId) \
   case BuiltinType::Id:

clang/lib/Sema/SemaOpenMP.cpp

if (DepKind == OMPC_DEPEND_sink) {
         // mutexinoutset dependence types cannot be expressions of the
         // omp_depend_t type.
         if (!RefExpr->isValueDependent() && !RefExpr->isTypeDependent() &&
             !RefExpr->isInstantiationDependent() &&
             !RefExpr->containsUnexpandedParameterPack() &&
             (OMPDependTFound &&
              DSAStack->getOMPDependT().getTypePtr() == ExprTy.getTypePtr())) {
           Diag(ELoc, diag::err_omp_expected_addressable_lvalue_or_array_item)
-              << 1 << RefExpr->getSourceRange();
+              << (LangOpts.OpenMP >= 50 ? 1 : 0) << 1
+              << RefExpr->getSourceRange();
           continue;
         }
 
         auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr);
         if (!RefExpr->IgnoreParenImpCasts()->isLValue() ||
             (ASE &&
              !ASE->getBase()
                   ->getType()
                   .getNonReferenceType()
                   ->isPointerType() &&
              !ASE->getBase()->getType().getNonReferenceType()->isArrayType())) {
           Diag(ELoc, diag::err_omp_expected_addressable_lvalue_or_array_item)
+              << (LangOpts.OpenMP >= 50 ? 1 : 0)
               << (LangOpts.OpenMP >= 50 ? 1 : 0) << RefExpr->getSourceRange();
           continue;
         }
 
         ExprResult Res;
         {
           Sema::TentativeAnalysisScope Trap(*this);
           Res = CreateBuiltinUnaryOp(ELoc, UO_AddrOf,
                                      RefExpr->IgnoreParenImpCasts());
         }
-        if (!Res.isUsable() && !isa<OMPArraySectionExpr>(SimpleExpr)) {
+        if (!Res.isUsable() && !isa<OMPArraySectionExpr>(SimpleExpr) &&
+            !isa<OMPArrayShapingExpr>(SimpleExpr)) {
           Diag(ELoc, diag::err_omp_expected_addressable_lvalue_or_array_item)
+              << (LangOpts.OpenMP >= 50 ? 1 : 0)
               << (LangOpts.OpenMP >= 50 ? 1 : 0) << RefExpr->getSourceRange();
           continue;
         }
       }
     }
     Vars.push_back(RefExpr->IgnoreParenImpCasts());
   }
 

clang/lib/Sema/TreeTransform.h

   ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
                                         Expr *LowerBound,
                                         SourceLocation ColonLoc, Expr *Length,
                                         SourceLocation RBracketLoc) {
     return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
                                               ColonLoc, Length, RBracketLoc);
   }
 
+  /// Build a new array shaping expression.
+  ///
+  /// By default, performs semantic analysis to build the new expression.
+  /// Subclasses may override this routine to provide different behavior.
+  ExprResult RebuildOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
+                                        SourceLocation RParenLoc,
+                                        ArrayRef<Expr *> Dims,
+                                        ArrayRef<SourceRange> BracketsRanges) {
+    return getSema().ActOnOMPArrayShapingExpr(Base, LParenLoc, RParenLoc, Dims,
+                                              BracketsRanges);
+  }
+
   /// Build a new call expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
                                    MultiExprArg Args,
                                    SourceLocation RParenLoc,
                                    Expr *ExecConfig = nullptr) {
if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
       LowerBound.get() == E->getLowerBound() && Length.get() == E->getLength())
     return E;
 
   return getDerived().RebuildOMPArraySectionExpr(
       Base.get(), E->getBase()->getEndLoc(), LowerBound.get(), E->getColonLoc(),
       Length.get(), E->getRBracketLoc());
 }
 
-template<typename Derived>
+template <typename Derived>
 ExprResult
+TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
+  ExprResult Base = getDerived().TransformExpr(E->getBase());
+  if (Base.isInvalid())
+    return ExprError();
+
+  SmallVector<Expr *, 4> Dims;
+  bool ErrorFound = false;
+  for (Expr *Dim : E->getDimensions()) {
+    ExprResult DimRes = getDerived().TransformExpr(Dim);
+    if (DimRes.isInvalid()) {
+      ErrorFound = true;
+      continue;
+    }
+    Dims.push_back(DimRes.get());
+  }
+
+  if (ErrorFound)
+    return ExprError();
+  return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(),
+                                                 E->getRParenLoc(), Dims,
+                                                 E->getBracketsRanges());
+}
+
+template<typename Derived>
+ExprResult
 TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
   // Transform the callee.
   ExprResult Callee = getDerived().TransformExpr(E->getCallee());
   if (Callee.isInvalid())
     return ExprError();
 
   // Transform arguments.
   bool ArgChanged = false;

clang/lib/Serialization/ASTCommon.cpp

case BuiltinType::Id: \
     break;
 #include "clang/Basic/AArch64SVEACLETypes.def"
   case BuiltinType::BuiltinFn:
     ID = PREDEF_TYPE_BUILTIN_FN;
     break;
   case BuiltinType::OMPArraySection:
     ID = PREDEF_TYPE_OMP_ARRAY_SECTION;
     break;
+  case BuiltinType::OMPArrayShaping:
+    ID = PREDEF_TYPE_OMP_ARRAY_SHAPING;
+    break;
   }
 
   return TypeIdx(ID);
 }
 
 unsigned serialization::ComputeHash(Selector Sel) {
   unsigned N = Sel.getNumArgs();
   if (N == 0)

clang/lib/Serialization/ASTReader.cpp

case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
       T = Context.ARCUnbridgedCastTy;
       break;
     case PREDEF_TYPE_BUILTIN_FN:
       T = Context.BuiltinFnTy;
       break;
     case PREDEF_TYPE_OMP_ARRAY_SECTION:
       T = Context.OMPArraySectionTy;
       break;
+    case PREDEF_TYPE_OMP_ARRAY_SHAPING:
+      T = Context.OMPArraySectionTy;
+      break;
 #define SVE_TYPE(Name, Id, SingletonId) \
     case PREDEF_TYPE_##Id##_ID: \
       T = Context.SingletonId; \
       break;
 #include "clang/Basic/AArch64SVEACLETypes.def"
     }
 
     assert(!T.isNull() && "Unknown predefined type");

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
   VisitExpr(E);
   E->setBase(Record.readSubExpr());
   E->setLowerBound(Record.readSubExpr());
   E->setLength(Record.readSubExpr());
   E->setColonLoc(readSourceLocation());
   E->setRBracketLoc(readSourceLocation());
 }
 
+void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
+  VisitExpr(E);
+  unsigned NumDims = Record.readInt();
+  E->setBase(Record.readSubExpr());
+  SmallVector<Expr *, 4> Dims(NumDims);
+  for (unsigned I = 0; I < NumDims; ++I)
+    Dims[I] = Record.readSubExpr();
+  E->setDimensions(Dims);
+  SmallVector<SourceRange, 4> SRs(NumDims);
+  for (unsigned I = 0; I < NumDims; ++I)
+    SRs[I] = readSourceRange();
+  E->setBracketsRanges(SRs);
+  E->setLParenLoc(readSourceLocation());
+  E->setRParenLoc(readSourceLocation());
+}
+
 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   unsigned NumArgs = Record.readInt();
   assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
   E->setRParenLoc(readSourceLocation());
   E->setCallee(Record.readSubExpr());
   for (unsigned I = 0; I != NumArgs; ++I)
     E->setArg(I, Record.readSubExpr());
while (true) {
     case EXPR_ARRAY_SUBSCRIPT:
       S = new (Context) ArraySubscriptExpr(Empty);
       break;
 
     case EXPR_OMP_ARRAY_SECTION:
       S = new (Context) OMPArraySectionExpr(Empty);
       break;
 
+    case EXPR_OMP_ARRAY_SHAPING:
+      S = OMPArrayShapingExpr::CreateEmpty(
+          Context, Record[ASTStmtReader::NumExprFields]);
+      break;
+
     case EXPR_CALL:
       S = CallExpr::CreateEmpty(
           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
       break;
 
     case EXPR_MEMBER:
       S = MemberExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields],
                                   Record[ASTStmtReader::NumExprFields + 1],

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
   Record.AddStmt(E->getBase());
   Record.AddStmt(E->getLowerBound());
   Record.AddStmt(E->getLength());
   Record.AddSourceLocation(E->getColonLoc());
   Record.AddSourceLocation(E->getRBracketLoc());
   Code = serialization::EXPR_OMP_ARRAY_SECTION;
 }
 
+void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
+  VisitExpr(E);
+  Record.push_back(E->getDimensions().size());
+  Record.AddStmt(E->getBase());
+  for (Expr *Dim : E->getDimensions())
+    Record.AddStmt(Dim);
+  for (SourceRange SR : E->getBracketsRanges())
+    Record.AddSourceRange(SR);
+  Record.AddSourceLocation(E->getLParenLoc());
+  Record.AddSourceLocation(E->getRParenLoc());
+  Code = serialization::EXPR_OMP_ARRAY_SHAPING;
+}
+
 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumArgs());
   Record.AddSourceLocation(E->getRParenLoc());
   Record.AddStmt(E->getCallee());
   for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
        Arg != ArgEnd; ++Arg)
     Record.AddStmt(*Arg);

clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp

static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
   }
 
   switch (Stmt1->getStmtClass()) {
   default:
     return false;
   case Stmt::CallExprClass:
   case Stmt::ArraySubscriptExprClass:
   case Stmt::OMPArraySectionExprClass:
+  case Stmt::OMPArrayShapingExprClass:
   case Stmt::ImplicitCastExprClass:
   case Stmt::ParenExprClass:
   case Stmt::BreakStmtClass:
   case Stmt::ContinueStmtClass:
   case Stmt::NullStmtClass:
     return true;
   case Stmt::CStyleCastExprClass: {
     const CStyleCastExpr* CastExpr1 = cast<CStyleCastExpr>(Stmt1);

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::SizeOfPackExprClass:
     case Stmt::StringLiteralClass:
     case Stmt::SourceLocExprClass:
     case Stmt::ObjCStringLiteralClass:
     case Stmt::CXXPseudoDestructorExprClass:
     case Stmt::SubstNonTypeTemplateParmExprClass:
     case Stmt::CXXNullPtrLiteralExprClass:
     case Stmt::OMPArraySectionExprClass:
+    case Stmt::OMPArrayShapingExprClass:
     case Stmt::TypeTraitExprClass: {
       Bldr.takeNodes(Pred);
       ExplodedNodeSet preVisit;
       getCheckerManager().runCheckersForPreStmt(preVisit, Pred, S, *this);
       getCheckerManager().runCheckersForPostStmt(Dst, preVisit, S, *this);
       Bldr.addNodes(Dst);
       break;
     }

clang/test/OpenMP/depobj_messages.cpp

 #pragma omp depobj(x) depend(in: argc) update(mutexinoutset) // expected-error {{exactly one of 'depend', 'destroy', or 'update' clauses is expected}}
 #pragma omp depobj(x) update(inout) destroy // expected-error {{exactly one of 'depend', 'destroy', or 'update' clauses is expected}}
 #pragma omp depobj(x) (x) depend(in: x) // expected-warning {{extra tokens at the end of '#pragma omp depobj' are ignored}}
 #pragma omp depobj(x) (x) update(in) // expected-warning {{extra tokens at the end of '#pragma omp depobj' are ignored}}
 #pragma omp depobj(x) depend(in: argc) depend(out:argc) // expected-error {{exactly one of 'depend', 'destroy', or 'update' clauses is expected}}
 #pragma omp depend(out:x) depobj(x) // expected-error {{expected an OpenMP directive}}
 #pragma omp destroy depobj(x) // expected-error {{expected an OpenMP directive}}
 #pragma omp update(out) depobj(x) // expected-error {{expected an OpenMP directive}}
-#pragma omp depobj depend(in:x) (x) // expected-error {{expected depobj expression}} expected-warning {{extra tokens at the end of '#pragma omp depobj' are ignored}} expected-error {{expected addressable lvalue expression, array element or array section of non 'omp_depend_t' type}}
+#pragma omp depobj depend(in:x) (x) // expected-error {{expected depobj expression}} expected-warning {{extra tokens at the end of '#pragma omp depobj' are ignored}} expected-error {{expected addressable lvalue expression, array element, array section or array shaping expression of non 'omp_depend_t' type}}
 #pragma omp depobj destroy (x) // expected-error {{expected depobj expression}} expected-warning {{extra tokens at the end of '#pragma omp depobj' are ignored}}
 #pragma omp depobj update(in) (x) // expected-error {{expected depobj expression}} expected-warning {{extra tokens at the end of '#pragma omp depobj' are ignored}}
   return tmain(argc); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}}
 }

clang/test/OpenMP/parallel_reduction_messages.c

-// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s
+// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -ferror-limit 150 -o - %s
+// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -fopenmp-version=50 -ferror-limit 150 -o - %s
 
 int incomplete[];
 
-void test() {
-#pragma omp parallel reduction(+ : incomplete) // expected-error {{a reduction list item with incomplete type 'int []'}}
+void test(int *p) {
+#pragma omp parallel reduction(+ : incomplete, ([10])p) // expected-error {{a reduction list item with incomplete type 'int []'}} omp45-error {{expected expression}} omp50-error {{expected variable name, array element or array section}}
   ;
 }
 
 // complete to suppress an additional warning, but it's too late for pragmas
 int incomplete[3];

clang/test/OpenMP/task_ast_print.cpp

 
 template <typename T, int C>
 T tmain(T argc, T *argv) {
   T b = argc, c, d, e, f, g;
   static T a;
   S<T> s;
   T arr[argc];
   omp_depend_t x;
-#pragma omp task untied depend(in : argc, argv[b:argc], arr[:]) if (task : argc > 0) depend(depobj: x)
+#pragma omp task untied depend(in : argc, argv[b:argc], arr[:], ([argc])argv) if (task : argc > 0) depend(depobj: x)
   a = 2;
 #pragma omp task default(none), private(argc, b) firstprivate(argv) shared(d) if (argc > 0) final(S<T>::TS > 0) priority(argc)
   foo();
 #pragma omp taskgroup task_reduction(-: argc)
 #pragma omp task if (C) mergeable priority(C) in_reduction(-: argc)
   foo();
   return 0;
 }
 
 // CHECK: template <typename T, int C> T tmain(T argc, T *argv) {
 // CHECK-NEXT: T b = argc, c, d, e, f, g;
 // CHECK-NEXT: static T a;
 // CHECK-NEXT: S<T> s;
 // CHECK-NEXT: T arr[argc];
 // CHECK-NEXT: omp_depend_t x;
-// CHECK-NEXT: #pragma omp task untied depend(in : argc,argv[b:argc],arr[:]) if(task: argc > 0) depend(depobj : x)
+// CHECK-NEXT: #pragma omp task untied depend(in : argc,argv[b:argc],arr[:],([argc])argv) if(task: argc > 0) depend(depobj : x)
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<T>::TS > 0) priority(argc)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp taskgroup task_reduction(-: argc)
 // CHECK-NEXT: #pragma omp task if(C) mergeable priority(C) in_reduction(-: argc)
 // CHECK-NEXT: foo()
 // CHECK: template<> int tmain<int, 5>(int argc, int *argv) {
 // CHECK-NEXT: int b = argc, c, d, e, f, g;
 // CHECK-NEXT: static int a;
 // CHECK-NEXT: S<int> s;
 // CHECK-NEXT: int arr[argc];
 // CHECK-NEXT: omp_depend_t x;
-// CHECK-NEXT: #pragma omp task untied depend(in : argc,argv[b:argc],arr[:]) if(task: argc > 0) depend(depobj : x)
+// CHECK-NEXT: #pragma omp task untied depend(in : argc,argv[b:argc],arr[:],([argc])argv) if(task: argc > 0) depend(depobj : x)
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<int>::TS > 0) priority(argc)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp taskgroup task_reduction(-: argc)
 // CHECK-NEXT: #pragma omp task if(5) mergeable priority(5) in_reduction(-: argc)
 // CHECK-NEXT: foo()
 // CHECK: template<> long tmain<long, 1>(long argc, long *argv) {
 // CHECK-NEXT: long b = argc, c, d, e, f, g;
 // CHECK-NEXT: static long a;
 // CHECK-NEXT: S<long> s;
 // CHECK-NEXT: long arr[argc];
 // CHECK-NEXT: omp_depend_t x;
-// CHECK-NEXT: #pragma omp task untied depend(in : argc,argv[b:argc],arr[:]) if(task: argc > 0) depend(depobj : x)
+// CHECK-NEXT: #pragma omp task untied depend(in : argc,argv[b:argc],arr[:],([argc])argv) if(task: argc > 0) depend(depobj : x)
 // CHECK-NEXT: a = 2;
 // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<long>::TS > 0) priority(argc)
 // CHECK-NEXT: foo()
 // CHECK-NEXT: #pragma omp taskgroup task_reduction(-: argc)
 // CHECK-NEXT: #pragma omp task if(1) mergeable priority(1) in_reduction(-: argc)
 // CHECK-NEXT: foo()
 
 enum Enum {};
 
 int main(int argc, char **argv) {
   long x;
   int b = argc, c, d, e, f, g;
   static int a;
   int arr[10], arr1[argc];
   omp_depend_t y;
 #pragma omp threadprivate(a)
   Enum ee;
 // CHECK: Enum ee;
-#pragma omp task untied mergeable depend(out:argv[:a][1], (arr)[0:]) if(task: argc > 0) priority(f) depend(depobj:y)
-  // CHECK-NEXT: #pragma omp task untied mergeable depend(out : argv[:a][1],(arr)[0:]) if(task: argc > 0) priority(f) depend(depobj : y)
+#pragma omp task untied mergeable depend(out:argv[:a][1], (arr)[0:],([argc][10])argv) if(task: argc > 0) priority(f) depend(depobj:y)
+  // CHECK-NEXT: #pragma omp task untied mergeable depend(out : argv[:a][1],(arr)[0:],([argc][10])argv) if(task: argc > 0) priority(f) depend(depobj : y)
   a = 2;
 // CHECK-NEXT: a = 2;
 #pragma omp taskgroup task_reduction(min: arr1)
-#pragma omp task default(none), private(argc, b) firstprivate(argv) if (argc > 0) final(a > 0) depend(inout : a, argv[:argc],arr[:a]) priority(23) in_reduction(min: arr1)
+#pragma omp task default(none), private(argc, b) firstprivate(argv) if (argc > 0) final(a > 0) depend(inout : a, argv[:argc],arr[:a], ([10][argc])argv) priority(23) in_reduction(min: arr1)
   // CHECK-NEXT: #pragma omp taskgroup task_reduction(min: arr1)
-  // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) if(argc > 0) final(a > 0) depend(inout : a,argv[:argc],arr[:a]) priority(23) in_reduction(min: arr1)
+  // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) if(argc > 0) final(a > 0) depend(inout : a,argv[:argc],arr[:a],([10][argc])argv) priority(23) in_reduction(min: arr1)
   foo();
   // CHECK-NEXT: foo();
 #pragma omp taskgroup task_reduction(min: arr1)
 #pragma omp parallel reduction(+:arr1)
 #pragma omp task in_reduction(min: arr1)
   // CHECK-NEXT: #pragma omp taskgroup task_reduction(min: arr1)
   // CHECK-NEXT: #pragma omp parallel reduction(+: arr1)
   // CHECK-NEXT: #pragma omp task in_reduction(min: arr1)

clang/test/OpenMP/task_depend_messages.cpp

int main(int argc, char **argv, char *env[]) {
   #pragma omp task depend // expected-error {{expected '(' after 'depend'}}
   #pragma omp task depend ( // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-warning {{missing ':' after dependency type - ignoring}} omp50-error {{expected 'in', 'out', 'inout', 'mutexinoutset' or 'depobj' in OpenMP clause 'depend'}}
   #pragma omp task depend () // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} expected-warning {{missing ':' after dependency type - ignoring}} omp50-error {{expected 'in', 'out', 'inout', 'mutexinoutset' or 'depobj' in OpenMP clause 'depend'}}
   #pragma omp task depend (argc // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} expected-warning {{missing ':' after dependency type - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} omp50-error {{expected 'in', 'out', 'inout', 'mutexinoutset' or 'depobj' in OpenMP clause 'depend'}}
   #pragma omp task depend (source : argc) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{expected 'in', 'out', 'inout', 'mutexinoutset' or 'depobj' in OpenMP clause 'depend'}}
   #pragma omp task depend (source) // expected-error {{expected expression}} expected-warning {{missing ':' after dependency type - ignoring}} omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{expected 'in', 'out', 'inout', 'mutexinoutset' or 'depobj' in OpenMP clause 'depend'}}
   #pragma omp task depend (in : argc)) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}}
   #pragma omp task depend (out: ) // expected-error {{expected expression}}
-  #pragma omp task depend (inout : foobool(argc)), depend (in, argc) // expected-error {{expected addressable lvalue expression, array element or array section}} expected-warning {{missing ':' after dependency type - ignoring}} expected-error {{expected expression}}
+  #pragma omp task depend (inout : foobool(argc)), depend (in, argc) // omp50-error {{expected addressable lvalue expression, array element, array section or array shaping expression}} omp45-error {{expected addressable lvalue expression, array element or array section}} expected-warning {{missing ':' after dependency type - ignoring}} expected-error {{expected expression}}
   #pragma omp task depend (out :S1) // expected-error {{'S1' does not refer to a value}}
   #pragma omp task depend(in : argv[1][1] = '2')
-  #pragma omp task depend (in : vec[1]) // expected-error {{expected addressable lvalue expression, array element or array section}}
+  #pragma omp task depend (in : vec[1]) // omp50-error {{expected addressable lvalue expression, array element, array section or array shaping expression}} omp45-error {{expected addressable lvalue expression, array element or array section}}
   #pragma omp task depend (in : argv[0])
   #pragma omp task depend (in : ) // expected-error {{expected expression}}
   #pragma omp task depend (in : main)
-  #pragma omp task depend(in : a[0]) // expected-error{{expected addressable lvalue expression, array element or array section}}
+  #pragma omp task depend(in : a[0]) // omp50-error {{expected addressable lvalue expression, array element, array section or array shaping expression}} omp45-error {{expected addressable lvalue expression, array element or array section}}
   #pragma omp task depend (in : vec[1:2]) // expected-error {{ value is not an array or pointer}}
   #pragma omp task depend (in : argv[ // expected-error {{expected expression}} expected-error {{expected ']'}} expected-error {{expected ')'}} expected-note {{to match this '['}} expected-note {{to match this '('}}
   #pragma omp task depend (in : argv[: // expected-error {{expected expression}} expected-error {{expected ']'}} expected-error {{expected ')'}} expected-note {{to match this '['}} expected-note {{to match this '('}}
   #pragma omp task depend (in : argv[:] // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   #pragma omp task depend (in : argv[argc: // expected-error {{expected expression}} expected-error {{expected ']'}} expected-error {{expected ')'}} expected-note {{to match this '['}} expected-note {{to match this '('}}
   #pragma omp task depend (in : argv[argc:argc] // expected-error {{expected ')'}} expected-note {{to match this '('}}
   #pragma omp task depend (in : argv[0:-1]) // expected-error {{section length is evaluated to a negative value -1}}
   #pragma omp task depend (in : argv[-1:0]) // expected-error {{zero-length array section is not allowed in 'depend' clause}}
   #pragma omp task depend (in : argv[:]) // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
   #pragma omp task depend (in : argv[3:4:1]) // expected-error {{expected ']'}} expected-note {{to match this '['}}
   #pragma omp task depend(in:a[0:1]) // expected-error {{subscripted value is not an array or pointer}}
   #pragma omp task depend(in:argv[argv[:2]:1]) // expected-error {{OpenMP array section is not allowed here}}
   #pragma omp task depend(in:argv[0:][:]) // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
   #pragma omp task depend(in:env[0:][:]) // expected-error {{section length is unspecified and cannot be inferred because subscripted value is an array of unknown bound}}
   #pragma omp task depend(in : argv[ : argc][1 : argc - 1])
   #pragma omp task depend(in : arr[0])
   #pragma omp task depend(depobj:argc) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{expected lvalue expression of 'omp_depend_t' type, not 'int'}}
   #pragma omp task depend(depobj : argv[ : argc][1 : argc - 1]) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}} omp50-error {{expected lvalue expression of 'omp_depend_t' type, not '<OpenMP array section type>'}}
   #pragma omp task depend(depobj : arr[0]) // omp45-error {{expected 'in', 'out', 'inout' or 'mutexinoutset' in OpenMP clause 'depend'}}
+  #pragma omp task depend(in : ([ // expected-error {{expected variable name or 'this' in lambda capture list}} expected-error {{expected ')'}} expected-note {{to match this '('}}
+  #pragma omp task depend(in : ([] // expected-error {{expected body of lambda expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
+  #pragma omp task depend(in : ([]) // omp45-error {{expected body of lambda expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} omp50-error 2 {{expected expression}}
+  #pragma omp task depend(in : ([])a // omp45-error {{expected body of lambda expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} omp50-error {{expected expression}}
+  #pragma omp task depend(in : ([])a) // omp45-error {{expected body of lambda expression}} omp50-error {{expected expression}}
+  #pragma omp task depend(in : ([a])a) // omp45-error {{expected body of lambda expression}} omp50-error {{expected pointer type expression as a base of an array shaping operation}}
+  #pragma omp task depend(in : ([a])argc) // omp45-error {{expected body of lambda expression}} omp50-error {{expected pointer type expression as a base of an array shaping operation}}
+  #pragma omp task depend(in : ([-1][0])argv) // omp45-error {{expected variable name or 'this' in lambda capture list}} omp45-error {{expected ')'}} omp45-note {{to match this '('}} omp50-error {{array shaping dimension is evaluated to a non-positive value -1}} omp50-error {{array shaping dimension is evaluated to a non-positive value 0}}
   foo();
 
   return 0;
 }

clang/tools/libclang/CIndex.cpp

CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_ParenExpr:
       return cxstring::createRef("ParenExpr");
   case CXCursor_UnaryOperator:
       return cxstring::createRef("UnaryOperator");
   case CXCursor_ArraySubscriptExpr:
       return cxstring::createRef("ArraySubscriptExpr");
   case CXCursor_OMPArraySectionExpr:
       return cxstring::createRef("OMPArraySectionExpr");
+  case CXCursor_OMPArrayShapingExpr:
+      return cxstring::createRef("OMPArrayShapingExpr");
   case CXCursor_BinaryOperator:
       return cxstring::createRef("BinaryOperator");
   case CXCursor_CompoundAssignOperator:
       return cxstring::createRef("CompoundAssignOperator");
   case CXCursor_ConditionalOperator:
       return cxstring::createRef("ConditionalOperator");
   case CXCursor_CStyleCastExpr:
       return cxstring::createRef("CStyleCastExpr");

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::ArraySubscriptExprClass:
     K = CXCursor_ArraySubscriptExpr;
     break;
 
   case Stmt::OMPArraySectionExprClass:
     K = CXCursor_OMPArraySectionExpr;
     break;
 
+  case Stmt::OMPArrayShapingExprClass:
+    K = CXCursor_OMPArrayShapingExpr;
+    break;
+
   case Stmt::BinaryOperatorClass:
     K = CXCursor_BinaryOperator;
     break;
 
   case Stmt::CompoundAssignOperatorClass:
     K = CXCursor_CompoundAssignOperator;
     break;